fauna-api 0.0.0-stage → 1.0.679

package/dist/src/cicada/conversations.js

@@ -0,0 +1,236 @@
+import { Cicada } from "./index.js";
+function wrapConversation(raw) {
+    return {
+        ...raw,
+        inboxId: raw.inboxId !== undefined ? String(raw.inboxId) : undefined,
+        activeAt: new Date(raw.activeAt)
+    };
+}
+function wrapMessage(raw) {
+    return {
+        ...raw,
+        createdAt: new Date(raw.createdAt),
+        attachments: raw.attachments ?? [],
+        agent: raw.agent === true,
+    };
+}
+async function listView(authorization, path, inboxId) {
+    const response = await fetch(`${Cicada.getURL()}${path}`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify(inboxId ? { inboxId } : {})
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    const json = await response.json();
+    return json.map(wrapConversation);
+}
+// The inbox working set: everything except archived threads and conversations
+// parked for a future reminder.
+export async function listInbox(authorization, inboxId) {
+    return listView(authorization, '/cicada/inbox', inboxId);
+}
+// The archive.
+export async function listArchived(authorization, inboxId) {
+    return listView(authorization, '/cicada/archived', inboxId);
+}
+// Threads with a pending (future) remindAt, each paired with its due time.
+export async function listReminders(authorization, inboxId) {
+    const response = await fetch(`${Cicada.getURL()}/cicada/reminders`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify(inboxId ? { inboxId } : {})
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    const json = await response.json();
+    return json.map((raw) => ({
+        conversation: wrapConversation(raw.conversation),
+        remindAt: new Date(raw.remindAt)
+    }));
+}
+// Fetch a single conversation's metadata by id (hydrated participants), or null
+// if it no longer exists.
+export async function get(authorization, conversation) {
+    const response = await fetch(`${Cicada.getURL()}/cicada/conversation/get`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ conversation })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    const json = await response.json();
+    return json ? wrapConversation(json) : null;
+}
+export async function read(authorization, conversation) {
+    const response = await fetch(`${Cicada.getURL()}/cicada/conversation`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ conversation })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    const json = await response.json();
+    return json.map(wrapMessage);
+}
+// Suggest a continuation of an in-progress reply for a conversation. Returns
+// the raw completion text (the part that should follow the current draft); an
+// empty string means no suggestion.
+export async function autocomplete(authorization, conversation, text) {
+    const response = await fetch(`${Cicada.getURL()}/cicada/autocomplete`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ conversation, text })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return await response.text();
+}
+export async function markRead(authorization, conversation) {
+    const response = await fetch(`${Cicada.getURL()}/cicada/conversation/mark-read`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ conversation })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+}
+// Permanently delete a conversation (index entry + stored messages). Backfill
+// won't repopulate it — it only runs on account link, and polling fetches
+// deltas, so old messages never re-arrive.
+export async function remove(authorization, conversation) {
+    const response = await fetch(`${Cicada.getURL()}/cicada/conversation/delete`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ conversation })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+}
+// Start (or append to) conversations with picked contacts on a platform.
+// `recipients` are contact keys (email/handle/phone). `broadcast` sends a
+// separate 1:1 to each; `group` sends one shared thread (collapsing to
+// broadcast on platforms without a real group path). Returns the affected
+// conversation ids — open the first to show the resulting thread.
+export async function compose(authorization, options) {
+    const response = await fetch(`${Cicada.getURL()}/cicada/compose`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify(options)
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    const json = await response.json();
+    return json.conversationIds;
+}
+export async function send(authorization, conversation, text, platform) {
+    const response = await fetch(`${Cicada.getURL()}/cicada/send`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ conversation, text, platform })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    const json = await response.json();
+    return json.id;
+}
+// Move a conversation in/out of the archive.
+export async function archive(authorization, conversation, archived) {
+    const response = await fetch(`${Cicada.getURL()}/cicada/conversation/archive`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ conversation, archived })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+}
+// Set (or clear, with `at = null`) a reminder on a conversation. When the time
+// arrives the server re-surfaces the thread at the top of the inbox.
+export async function remind(authorization, conversation, at) {
+    const response = await fetch(`${Cicada.getURL()}/cicada/conversation/remind`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ conversation, at: at ? at.toISOString() : null })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+}
+// Queue an outbound message for later. Provide `conversationId` to reply into an
+// existing thread, or `compose` to start a fresh one. Returns the queue id.
+export async function schedule(authorization, options) {
+    const response = await fetch(`${Cicada.getURL()}/cicada/schedule`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ ...options, sendAt: options.sendAt.toISOString() })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    const json = await response.json();
+    return json.id;
+}
+export async function listScheduled(authorization, inboxId) {
+    const response = await fetch(`${Cicada.getURL()}/cicada/scheduled/list`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify(inboxId ? { inboxId } : {})
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    const json = await response.json();
+    return json.map((raw) => ({
+        ...raw,
+        sendAt: new Date(raw.sendAt),
+        createdAt: new Date(raw.createdAt)
+    }));
+}
+export async function cancelScheduled(authorization, scheduled) {
+    const response = await fetch(`${Cicada.getURL()}/cicada/scheduled/cancel`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ scheduled })
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+}

package/dist/src/cicada/inboxes.d.ts

@@ -0,0 +1,48 @@
+import { Cicada } from "./index.js";
+import { Platform } from "../integrations.js";
+import { Credentials, ApiKey } from "../authentification.js";
+import type { Text } from "../parrot/generative.js";
+export type InboxGroup = {
+    id: string;
+    name: string;
+    icon?: string;
+};
+export type Inbox = {
+    id: string;
+    name: string;
+    createdAt: Date;
+    group?: InboxGroup;
+};
+export type InboxAccount = {
+    platform: Platform;
+    accountId: string;
+};
+export declare function list(authorization: Credentials | ApiKey): Promise<Inbox[]>;
+export declare function create(authorization: Credentials | ApiKey, name: string): Promise<Inbox>;
+export declare function rename(authorization: Credentials | ApiKey, inboxId: string, name: string): Promise<Inbox>;
+export declare function remove(authorization: Credentials | ApiKey, inboxId: string): Promise<void>;
+export declare function moveToGroup(authorization: Credentials | ApiKey, inboxId: string, groupId: string): Promise<Inbox>;
+export declare function assign(authorization: Credentials | ApiKey, inboxId: string, account: {
+    platform: Platform;
+    accountId: string;
+}): Promise<void>;
+export declare function listAccounts(authorization: Credentials | ApiKey, inboxId: string): Promise<InboxAccount[]>;
+/** `dailyLimit` and `spentToday` are dollars per UTC day; at the limit the agent pauses until midnight UTC. */
+export type AgentSettings = {
+    model: Text;
+    instructions: string;
+    dailyLimit: number;
+    spentToday: number;
+    enabledAt: Date;
+};
+export declare const AgentSettings: {
+    fromJSON(json: any): AgentSettings;
+};
+export declare function getAgent(authorization: Credentials | ApiKey, inbox: string): Promise<AgentSettings | undefined>;
+/** Turns the agent on (it answers messages sent from now on) or updates it. */
+export declare function setAgent(authorization: Credentials | ApiKey, inbox: string, settings: {
+    model: Text;
+    instructions: string;
+    dailyLimit: number;
+}): Promise<AgentSettings>;
+export declare function clearAgent(authorization: Credentials | ApiKey, inbox: string): Promise<void>;

package/dist/src/cicada/inboxes.js

@@ -0,0 +1,82 @@
+import { Cicada } from "./index.js";
+async function post(authorization, path, body) {
+    const response = await fetch(`${Cicada.getURL()}${path}`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify(body ?? {})
+    });
+    if (!response.ok)
+        throw new Error(await response.text());
+    return response;
+}
+function wrapInbox(raw) {
+    const group = raw.group && typeof raw.group === 'object'
+        ? {
+            id: String(raw.group.id),
+            name: String(raw.group.name ?? ''),
+            ...(raw.group.icon ? { icon: String(raw.group.icon) } : {}),
+        }
+        : undefined;
+    return {
+        id: String(raw.id),
+        name: raw.name,
+        createdAt: new Date(raw.createdAt),
+        ...(group ? { group } : {}),
+    };
+}
+export async function list(authorization) {
+    const response = await post(authorization, '/cicada/inboxes');
+    return (await response.json()).map(wrapInbox);
+}
+export async function create(authorization, name) {
+    const response = await post(authorization, '/cicada/inboxes/create', { name });
+    return wrapInbox(await response.json());
+}
+export async function rename(authorization, inboxId, name) {
+    const response = await post(authorization, '/cicada/inboxes/rename', { inbox: inboxId, name });
+    return wrapInbox(await response.json());
+}
+export async function remove(authorization, inboxId) {
+    await post(authorization, '/cicada/inboxes/delete', { inbox: inboxId });
+}
+export async function moveToGroup(authorization, inboxId, groupId) {
+    const response = await post(authorization, '/cicada/inboxes/move', { inbox: inboxId, group: groupId });
+    return wrapInbox(await response.json());
+}
+export async function assign(authorization, inboxId, account) {
+    await post(authorization, '/cicada/inboxes/accounts', { inbox: inboxId, ...account });
+}
+export async function listAccounts(authorization, inboxId) {
+    const response = await post(authorization, '/cicada/inboxes/accounts/list', { inbox: inboxId });
+    return (await response.json()).map((raw) => ({
+        platform: raw.platform,
+        accountId: raw.accountId
+    }));
+}
+export const AgentSettings = {
+    fromJSON(json) {
+        return {
+            model: json.model,
+            instructions: String(json.instructions ?? ''),
+            dailyLimit: Number(json.dailyLimit ?? 0),
+            spentToday: Number(json.spentToday ?? 0),
+            enabledAt: new Date(json.enabledAt),
+        };
+    },
+};
+export async function getAgent(authorization, inbox) {
+    const response = await post(authorization, '/cicada/inboxes/agent', { inbox });
+    const text = await response.text();
+    return text.trim() ? AgentSettings.fromJSON(JSON.parse(text)) : undefined;
+}
+/** Turns the agent on (it answers messages sent from now on) or updates it. */
+export async function setAgent(authorization, inbox, settings) {
+    const response = await post(authorization, '/cicada/inboxes/agent/set', { inbox, ...settings });
+    return AgentSettings.fromJSON(await response.json());
+}
+export async function clearAgent(authorization, inbox) {
+    await post(authorization, '/cicada/inboxes/agent/clear', { inbox });
+}

package/dist/src/cicada/index.d.ts

@@ -0,0 +1,16 @@
+import * as ContactsAPI from "./contacts.js";
+import * as ConversationsAPI from "./conversations.js";
+import * as InboxesAPI from "./inboxes.js";
+import * as PhoneAPI from "./phone.js";
+export declare namespace Cicada {
+    function setRoute(route: string): void;
+    function getIP(): string;
+    function getPort(): number;
+    function getRoute(): string;
+    function getURL(): string;
+    function ping(): Promise<number>;
+    export import Contacts = ContactsAPI;
+    export import Conversations = ConversationsAPI;
+    export import Inboxes = InboxesAPI;
+    export import Phone = PhoneAPI;
+}

package/dist/src/cicada/index.js

@@ -0,0 +1,61 @@
+import * as ContactsAPI from "./contacts.js";
+import * as ConversationsAPI from "./conversations.js";
+import * as InboxesAPI from "./inboxes.js";
+import * as PhoneAPI from "./phone.js";
+export var Cicada;
+(function (Cicada) {
+    var PREFIX = 'https://';
+    var IP = 'api.faunakit.com';
+    var PORT = 443;
+    function setRoute(route) {
+        const parts_0 = route.split('//');
+        if (parts_0.length > 1) {
+            PREFIX = parts_0[0] + '//';
+            const parts_1 = parts_0[1].split(':');
+            if (parts_1.length > 1) {
+                IP = parts_1[0];
+                PORT = Number(parts_1[1]);
+            }
+            else {
+                IP = parts_1[0];
+            }
+        }
+        else {
+            const parts_1 = parts_0[0].split(':');
+            if (parts_1.length > 1) {
+                IP = parts_1[0];
+                PORT = Number(parts_1[1]);
+            }
+            else {
+                IP = parts_1[0];
+            }
+        }
+    }
+    Cicada.setRoute = setRoute;
+    function getIP() {
+        return IP;
+    }
+    Cicada.getIP = getIP;
+    function getPort() {
+        return PORT;
+    }
+    Cicada.getPort = getPort;
+    function getRoute() {
+        return IP + ':' + PORT;
+    }
+    Cicada.getRoute = getRoute;
+    function getURL() {
+        return PREFIX + IP + ':' + PORT;
+    }
+    Cicada.getURL = getURL;
+    async function ping() {
+        const start = Date.now();
+        await fetch(`${getURL()}/`);
+        return Date.now() - start;
+    }
+    Cicada.ping = ping;
+    Cicada.Contacts = ContactsAPI;
+    Cicada.Conversations = ConversationsAPI;
+    Cicada.Inboxes = InboxesAPI;
+    Cicada.Phone = PhoneAPI;
+})(Cicada || (Cicada = {}));

package/dist/src/cicada/phone.d.ts

@@ -0,0 +1,48 @@
+import { Credentials, ApiKey } from "../authentification.js";
+import WebSocket from "isomorphic-ws";
+export type CallEnd = {
+    status: 'COMPLETED' | 'NO_ANSWER' | 'BUSY' | 'FAILED' | 'CANCELED';
+    duration: number;
+};
+export type RingEnd = 'ACCEPTED' | 'TAKEN' | 'VOICEMAIL' | 'HUNG_UP';
+export declare class PhoneCall {
+    #private;
+    readonly id: string;
+    readonly direction: 'IN' | 'OUT';
+    /** The linked Twilio number, E.164. */
+    readonly line: string;
+    /** The other party, E.164. */
+    readonly peer: string;
+    status: 'RINGING' | 'ACTIVE' | 'ENDED';
+    private constructor();
+    /** Calls `listener` when the call is answered (ACTIVE) and when it ends (ENDED). */
+    onStatus(listener: (status: PhoneCall['status']) => void): () => void;
+    /** The other party's audio: PCM16 mono 16 kHz, the same as generateVoice's audio input. */
+    audio(): AsyncIterable<Uint8Array>;
+    /** Audio to the other party: PCM16 mono 24 kHz, the same as generateVoice's audio output. */
+    send(pcm: Uint8Array): void;
+    hangup(): Promise<void>;
+    /** Resolves once the call is over. duration is seconds of talk, 0 when never answered. */
+    ended(): Promise<CallEnd>;
+    static fromJSON(json: any, ws: WebSocket): PhoneCall;
+}
+export declare class IncomingCall {
+    #private;
+    readonly id: string;
+    /** The inbox's number that was called. */
+    readonly line: string;
+    /** Who is calling. */
+    readonly peer: string;
+    private constructor();
+    /** Rejects with "Someone else took the call." when another listener won. */
+    accept(): Promise<PhoneCall>;
+    /** Resolves when it stops ringing for you. */
+    ringing(): Promise<RingEnd>;
+    static fromJSON(json: any, authorization: Credentials | ApiKey): IncomingCall;
+}
+/** Rings for calls to any Twilio number linked to the inbox, until close(). */
+export declare function listen(authorization: Credentials | ApiKey, inbox: string, onIncoming: (call: IncomingCall) => void): Promise<{
+    close(): void;
+}>;
+/** Calls `to` from one of the inbox's phone lines: `from`, or its first line. */
+export declare function call(authorization: Credentials | ApiKey, inbox: string, to: string, from?: string): Promise<PhoneCall>;