iMessage

# At create time
identity = inkbox.create_identity("my-agent", imessage_enabled=True)

# Or toggle later
identity.update(imessage_enabled=True)
print(identity.imessage_enabled, identity.imessage_filter_mode)

// At create time
const identity = await inkbox.createIdentity("my-agent", { imessageEnabled: true });

// Or toggle later
await identity.update({ imessageEnabled: true });
console.log(identity.imessageEnabled, identity.imessageFilterMode);

# At create time
inkbox identity create my-agent --imessage-enabled

# Or toggle later
inkbox identity update my-agent --imessage-enabled true

identity.update(contact_sharing_enabled=False)

await identity.update({ contactSharingEnabled: false });

inkbox identity update my-agent --contact-sharing-enabled false

identity = inkbox.create_identity(
    "dedicated-agent",
    imessage_enabled=True,
    claim_imessage_number=True,
)

# Or claim an unattached line for the organization
line = inkbox.imessages.claim_number(
    idempotency_key="claim-dedicated-agent-01",
)

const identity = await inkbox.createIdentity("dedicated-agent", {
  imessageEnabled: true,
  claimIMessageNumber: true,
});

// Or claim an unattached line for the organization
const line = await inkbox.imessages.claimNumber({
  idempotencyKey: "claim-dedicated-agent-01",
});

router = inkbox.imessages.get_triage_number()
print(router.number)           # the router's E.164 number
print(router.connect_command)  # e.g. 'connect @my-agent'

const router = await inkbox.imessages.getTriageNumber();
console.log(router.number);          // the router's E.164 number
console.log(router.connectCommand);  // e.g. 'connect @my-agent'

inkbox imessage triage-number
# number          the router's E.164 number
# connectCommand  e.g. 'connect @my-agent'

import re

# List conversations with latest-message previews
convos = identity.list_imessage_conversations(limit=20)
for c in convos:
    print(c.id, c.remote_number, c.unread_count, c.latest_text)

# Read a thread
msgs = identity.list_imessages(conversation_id=convos[0].id, limit=50)

# Reply only to an active phone-number conversation
conversation = convos[0]
if conversation.assignment_status == "active" and re.fullmatch(
    r"\+[1-9][0-9]{1,14}", conversation.remote_number or ""
):
    identity.send_imessage(
        conversation_id=conversation.id,
        text="On it — give me two minutes.",
    )

# Or address the connected recipient directly
identity.send_imessage(to="+15555550123", text="Done!")

// List conversations with latest-message previews
const convos = await identity.listIMessageConversations({ limit: 20 });
for (const c of convos) {
  console.log(c.id, c.remoteNumber, c.unreadCount, c.latestText);
}

// Read a thread
const msgs = await identity.listIMessages({ conversationId: convos[0].id, limit: 50 });

// Reply only to an active phone-number conversation
const conversation = convos[0];
if (
  conversation.assignmentStatus === "active" &&
  /^\+[1-9][0-9]{1,14}$/.test(conversation.remoteNumber ?? "")
) {
  await identity.sendIMessage({
    conversationId: conversation.id,
    text: "On it — give me two minutes.",
  });
}

// Or address the connected recipient directly
await identity.sendIMessage({ to: "+15555550123", text: "Done!" });

# List conversations with latest-message previews
inkbox imessage conversations -i my-agent --limit 20

# Read a thread
inkbox imessage conversation <conversation-id> -i my-agent

# Reply to an active phone-number conversation
inkbox imessage send -i my-agent \
--conversation-id <conversation-id> \
--text "On it — give me two minutes."

message = identity.get_imessage("1a90e8b0-0e1e-485f-b316-28f7dfa96afd")
reply = identity.send_imessage(
    conversation_id=message.conversation_id,
    reply_to_message_id=message.id,
    plain_reply_fallback=True,
    text="Friday works for me.",
)
thread = identity.get_imessage_thread(message.id, limit=50)
for item in thread.messages:
    print(item.id, item.reply_to_message_id, item.content)
if thread.next_cursor:
    next_page = identity.get_imessage_thread(
        message.id, cursor=thread.next_cursor,
    )
if thread.thread_id:
    same_thread = identity.get_imessage_conversation_thread(
        message.conversation_id, thread.thread_id,
    )

const message = await identity.getIMessage("1a90e8b0-0e1e-485f-b316-28f7dfa96afd");
const reply = await identity.sendIMessage({
  conversationId: message.conversationId,
  replyToMessageId: message.id,
  plainReplyFallback: true,
  text: "Friday works for me.",
});
const thread = await identity.getIMessageThread(message.id, { limit: 50 });
for (const item of thread.messages) {
  console.log(item.id, item.replyToMessageId, item.content);
}
if (thread.nextCursor) {
  const nextPage = await identity.getIMessageThread(message.id, {
    cursor: thread.nextCursor,
  });
}
if (thread.threadId) {
  const sameThread = await identity.getIMessageConversationThread(
    message.conversationId, thread.threadId,
  );
}

inkbox imessage send -i my-agent \
--conversation-id <conversation-id> \
--reply-to-message-id <message-id> \
--text "Friday works for me."

inkbox imessage thread <message-id> -i my-agent --limit 50
inkbox imessage conversation-thread <conversation-id> <thread-id> -i my-agent

group = identity.send_imessage(
    to=["+14155550100", "+14155550101"],
    text="Planning starts at 10.",
    send_style="confetti",
)
identity.send_imessage(
    conversation_id=group.conversation_id,
    text="I moved the start time to 10:30.",
    send_style="gentle",
)
groups = identity.list_imessage_conversations(include_groups=True)

const group = await identity.sendIMessage({
  to: ["+14155550100", "+14155550101"],
  text: "Planning starts at 10.",
  sendStyle: "confetti",
});
await identity.sendIMessage({
  conversationId: group.conversationId,
  text: "I moved the start time to 10:30.",
  sendStyle: "gentle",
});
const groups = await identity.listIMessageConversations({ includeGroups: true });

inkbox imessage send -i my-agent \
--to +14155550100,+14155550101 \
--text "Planning starts at 10." \
--send-style confetti

inkbox imessage conversations -i my-agent --include-groups
inkbox imessage send -i my-agent \
--conversation-id <conversation-id> \
--text "I moved the start time to 10:30." \
--send-style gentle

sent = identity.send_imessage_reaction(message_id=msgs[0].id, reaction="like")

# Live tapbacks come back on message reads, oldest first
for r in msgs[0].reactions or []:
    print(r.direction, r.reaction, r.custom_emoji)

# Take your own tapback back
identity.remove_imessage_reaction(sent.id)

const sent = await identity.sendIMessageReaction({ messageId: msgs[0].id, reaction: "like" });

// Live tapbacks come back on message reads, oldest first
for (const r of msgs[0].reactions ?? []) {
  console.log(r.direction, r.reaction, r.customEmoji);
}

// Take your own tapback back
await identity.removeIMessageReaction(sent.id);

inkbox imessage react <message-id> -i my-agent --reaction like
inkbox imessage unreact <reaction-id> -i my-agent

# Read receipt — the human sees "Read" under their message
identity.mark_imessage_conversation_read(convos[0].id)

# Typing indicator while the agent prepares a reply
identity.send_imessage_typing(convos[0].id)

# Upload media (max 10 MiB), then send the returned URL
upload = identity.upload_imessage_media(
    content=open("chart.png", "rb").read(),
    filename="chart.png",
    content_type="image/png",
)
identity.send_imessage(
    conversation_id=convos[0].id,
    media_urls=[upload.media_url],
)

// Read receipt — the human sees "Read" under their message
await identity.markIMessageConversationRead(convos[0].id);

// Typing indicator while the agent prepares a reply
await identity.sendIMessageTyping(convos[0].id);

// Upload media (max 10 MiB), then send the returned URL
const upload = await identity.uploadIMessageMedia({
  content: await readFile("chart.png"),
  filename: "chart.png",
  contentType: "image/png",
});
await identity.sendIMessage({
  conversationId: convos[0].id,
  mediaUrls: [upload.mediaUrl],
});

# Read receipt
inkbox imessage mark-conversation-read <conversation-id> -i my-agent

# Typing indicator
inkbox imessage typing <conversation-id> -i my-agent

# Upload media, then send the returned URL
inkbox imessage upload-media ./chart.png -i my-agent --content-type image/png
inkbox imessage send -i my-agent \
--conversation-id <conversation-id> \
--media-url <media-url>

# Block one number
rule = inkbox.imessage_contact_rules.create(
    "my-agent", action="block", match_target="+15555550999",
)

# Review the identity's rules
for r in inkbox.imessage_contact_rules.list("my-agent"):
    print(r.action, r.match_target, r.status)

# Flip to whitelist mode (admin API key required)
identity.update(imessage_filter_mode="whitelist")

// Block one number
const rule = await inkbox.imessageContactRules.create("my-agent", {
  action: "block",
  matchTarget: "+15555550999",
});

// Review the identity's rules
for (const r of await inkbox.imessageContactRules.list("my-agent")) {
  console.log(r.action, r.matchTarget, r.status);
}

// Flip to whitelist mode (admin API key required)
await identity.update({ imessageFilterMode: "whitelist" });

# Block one number
inkbox imessage contact-rule create -i my-agent \
--action block --match-target +15555550999

# Review the identity's rules
inkbox imessage contact-rule list -i my-agent

# Flip to whitelist mode (admin API key required)
inkbox identity update my-agent --imessage-filter-mode whitelist

inkbox.webhooks.subscriptions.create(
    agent_identity_id=identity.id,
    url="https://yourapp.example.com/webhooks/inkbox",
    event_types=["imessage.received", "imessage.reaction_received"],
)

await inkbox.webhooks.subscriptions.create({
  agentIdentityId: identity.id,
  url: "https://yourapp.example.com/webhooks/inkbox",
  eventTypes: ["imessage.received", "imessage.reaction_received"],
});

inkbox webhook subscription create \
--agent-identity-id <identity-id> \
--url https://yourapp.example.com/webhooks/inkbox \
--event-type imessage.received \
--event-type imessage.reaction_received