@adecore/agent-contracts 0.0.1 → 0.17.0-beta.2

package/dist/protocol.js

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { ChatAddBookmarkPayloadSchema, ChatAnswerPayloadSchema, ChatApprovePayloadSchema, ChatAttachPayloadSchema, ChatAttachResultSchema, ChatBookmarksEventSchema, ChatBookmarksResultSchema, ChatCancelPayloadSchema, ChatClearPayloadSchema, ChatConfigurePayloadSchema, ChatContinueOnPayloadSchema, ChatContinueOnResultSchema, ChatCreatePayloadSchema, ChatDismissPayloadSchema, ChatEventEnvelopeSchema, ChatForkInfoPayloadSchema, ChatForkInfoResultSchema, ChatForkPayloadSchema, ChatForkResultSchema, ChatHistoryPayloadSchema, ChatHistoryResultSchema, ChatInfoSchema, ChatListResultSchema, ChatPreferencesPayloadSchema, ChatQueuePayloadSchema, ChatRemoveBookmarkPayloadSchema, ChatRenameBookmarkPayloadSchema, ChatSendPayloadSchema, ChatSendResultSchema, ChatStatusEventSchema, ChatStopSubagentPayloadSchema, ChatStopTaskPayloadSchema, ChatSubagentChangedEventSchema, ChatSubagentPayloadSchema, ChatSubagentResultSchema, ChatSummarizePayloadSchema, ChatSummarizeResultSchema, ChatTargetPayloadSchema, ChatTurnDiffPayloadSchema, ChatTurnDiffResultSchema, ChatUnqueueResultSchema, SkillsListPayloadSchema, SkillsListResultSchema } from './chat.js';
+import { ProviderListResultSchema } from './model.js';
+import { ProviderAccountCreatePayloadSchema, ProviderAccountCreateResultSchema, ProviderAccountWatchLoginPayloadSchema, ProviderAccountsSavePayloadSchema, ProviderAccountsSchema } from './provider-accounts.js';
+import { UsageChangedEventSchema, UsageLimitsSnapshotSchema, UsageSummaryPayloadSchema, UsageSummaryResultSchema } from './usage.js';
+export const EmptySchema = z.object({});
+/*
+ * The requests a chat, its providers and their usage answer, with what goes in and what comes back.
+ * An application places each one in its own wire table, so a host that only runs chats serves
+ * exactly these and a client reads the same shapes either way.
+ */
+export const AGENT_REQUEST_SCHEMAS = {
+    'chat.create': { payload: ChatCreatePayloadSchema, result: ChatInfoSchema },
+    'chat.history': { payload: ChatHistoryPayloadSchema, result: ChatHistoryResultSchema },
+    'chat.attach': { payload: ChatAttachPayloadSchema, result: ChatAttachResultSchema },
+    'chat.detach': { payload: ChatTargetPayloadSchema, result: EmptySchema },
+    'chat.send': { payload: ChatSendPayloadSchema, result: ChatSendResultSchema },
+    'chat.unqueue': { payload: ChatQueuePayloadSchema, result: ChatUnqueueResultSchema },
+    'chat.sendNow': { payload: ChatQueuePayloadSchema, result: EmptySchema },
+    'chat.cancel': { payload: ChatCancelPayloadSchema, result: EmptySchema },
+    'chat.approve': { payload: ChatApprovePayloadSchema, result: EmptySchema },
+    'chat.answer': { payload: ChatAnswerPayloadSchema, result: EmptySchema },
+    'chat.dismiss': { payload: ChatDismissPayloadSchema, result: EmptySchema },
+    'chat.configure': { payload: ChatConfigurePayloadSchema, result: ChatInfoSchema },
+    'chat.setPreferences': { payload: ChatPreferencesPayloadSchema, result: EmptySchema },
+    'chat.compact': { payload: ChatTargetPayloadSchema, result: EmptySchema },
+    'chat.clear': { payload: ChatClearPayloadSchema, result: EmptySchema },
+    'chat.turnDiff': { payload: ChatTurnDiffPayloadSchema, result: ChatTurnDiffResultSchema },
+    'chat.fork': { payload: ChatForkPayloadSchema, result: ChatForkResultSchema },
+    'chat.continueOn': { payload: ChatContinueOnPayloadSchema, result: ChatContinueOnResultSchema },
+    'chat.forkInfo': { payload: ChatForkInfoPayloadSchema, result: ChatForkInfoResultSchema },
+    'chat.summarize': { payload: ChatSummarizePayloadSchema, result: ChatSummarizeResultSchema },
+    'chat.subagent': { payload: ChatSubagentPayloadSchema, result: ChatSubagentResultSchema },
+    'chat.stopSubagent': { payload: ChatStopSubagentPayloadSchema, result: EmptySchema },
+    'chat.stopTask': { payload: ChatStopTaskPayloadSchema, result: EmptySchema },
+    'chat.addBookmark': { payload: ChatAddBookmarkPayloadSchema, result: ChatBookmarksResultSchema },
+    'chat.renameBookmark': { payload: ChatRenameBookmarkPayloadSchema, result: ChatBookmarksResultSchema },
+    'chat.removeBookmark': { payload: ChatRemoveBookmarkPayloadSchema, result: ChatBookmarksResultSchema },
+    'skills.list': { payload: SkillsListPayloadSchema, result: SkillsListResultSchema },
+    'provider.list': { payload: EmptySchema, result: ProviderListResultSchema },
+    'accounts.list': { payload: EmptySchema, result: ProviderAccountsSchema },
+    'accounts.save': { payload: ProviderAccountsSavePayloadSchema, result: ProviderAccountsSchema },
+    // Asks every CLI again and answers once they all did.
+    'accounts.refresh': { payload: EmptySchema, result: ProviderAccountsSchema },
+    'accounts.create': { payload: ProviderAccountCreatePayloadSchema, result: ProviderAccountCreateResultSchema },
+    // Answers at once; what the CLI says arrives as `accounts.changed`.
+    'accounts.watchLogin': { payload: ProviderAccountWatchLoginPayloadSchema, result: EmptySchema },
+    'usage.summary': { payload: UsageSummaryPayloadSchema, result: UsageSummaryResultSchema },
+    'usage.subscribe': { payload: EmptySchema, result: EmptySchema },
+    'usage.unsubscribe': { payload: EmptySchema, result: EmptySchema },
+    'usage.limits': { payload: EmptySchema, result: UsageLimitsSnapshotSchema },
+    'usage.refreshLimits': { payload: EmptySchema, result: UsageLimitsSnapshotSchema },
+    'chat.kill': { payload: ChatTargetPayloadSchema, result: EmptySchema },
+    'chat.list': { payload: EmptySchema, result: ChatListResultSchema }
+};
+export const AGENT_EVENT_SCHEMAS = {
+    'chat.event': ChatEventEnvelopeSchema,
+    'chat.status': ChatStatusEventSchema,
+    'chat.subagentChanged': ChatSubagentChangedEventSchema,
+    'chat.bookmarks': ChatBookmarksEventSchema,
+    'usage.changed': UsageChangedEventSchema,
+    'usage.limitsChanged': UsageLimitsSnapshotSchema,
+    'accounts.changed': ProviderAccountsSchema
+};

package/dist/provider-accounts.d.ts

@@ -0,0 +1,199 @@
+import { z } from 'zod';
+export declare const ProviderAccountIdSchema: z.ZodString;
+export type ProviderAccountId = z.infer<typeof ProviderAccountIdSchema>;
+export declare const ProviderAccountVariableSchema: z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodString;
+    sensitive: z.ZodBoolean;
+    valueRedacted: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ProviderAccountVariable = z.infer<typeof ProviderAccountVariableSchema>;
+export declare const ProviderAccountSchema: z.ZodObject<{
+    kind: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    home: z.ZodOptional<z.ZodString>;
+    shadowHome: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+        sensitive: z.ZodBoolean;
+        valueRedacted: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ProviderAccount = z.infer<typeof ProviderAccountSchema>;
+export declare const ProviderAccountStateSchema: z.ZodEnum<{
+    checking: "checking";
+    disabled: "disabled";
+    failed: "failed";
+    "folder-missing": "folder-missing";
+    "not-found": "not-found";
+    ready: "ready";
+    "signed-out": "signed-out";
+    unavailable: "unavailable";
+}>;
+export type ProviderAccountState = z.infer<typeof ProviderAccountStateSchema>;
+export declare const ProviderAccountStatusSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodString;
+    state: z.ZodEnum<{
+        checking: "checking";
+        disabled: "disabled";
+        failed: "failed";
+        "folder-missing": "folder-missing";
+        "not-found": "not-found";
+        ready: "ready";
+        "signed-out": "signed-out";
+        unavailable: "unavailable";
+    }>;
+    email: z.ZodNullable<z.ZodString>;
+    plan: z.ZodNullable<z.ZodString>;
+    organization: z.ZodNullable<z.ZodString>;
+    home: z.ZodString;
+    transcripts: z.ZodOptional<z.ZodString>;
+    message: z.ZodNullable<z.ZodString>;
+    checkedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type ProviderAccountStatus = z.infer<typeof ProviderAccountStatusSchema>;
+export declare const ProviderAccountMapSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    kind: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    home: z.ZodOptional<z.ZodString>;
+    shadowHome: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        value: z.ZodString;
+        sensitive: z.ZodBoolean;
+        valueRedacted: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>>;
+export type ProviderAccountMap = z.infer<typeof ProviderAccountMapSchema>;
+export declare const ProviderAccountsSchema: z.ZodObject<{
+    accounts: z.ZodRecord<z.ZodString, z.ZodObject<{
+        kind: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        home: z.ZodOptional<z.ZodString>;
+        shadowHome: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            sensitive: z.ZodBoolean;
+            valueRedacted: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    statuses: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodString;
+        state: z.ZodEnum<{
+            checking: "checking";
+            disabled: "disabled";
+            failed: "failed";
+            "folder-missing": "folder-missing";
+            "not-found": "not-found";
+            ready: "ready";
+            "signed-out": "signed-out";
+            unavailable: "unavailable";
+        }>;
+        email: z.ZodNullable<z.ZodString>;
+        plan: z.ZodNullable<z.ZodString>;
+        organization: z.ZodNullable<z.ZodString>;
+        home: z.ZodString;
+        transcripts: z.ZodOptional<z.ZodString>;
+        message: z.ZodNullable<z.ZodString>;
+        checkedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    secretsAvailable: z.ZodOptional<z.ZodBoolean>;
+    loginCommands: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+        apple: "apple";
+        claude: "claude";
+        codex: "codex";
+        copilot: "copilot";
+        gemini: "gemini";
+    }> & z.core.$partial, z.ZodString>>;
+}, z.core.$strip>;
+export type ProviderAccounts = z.infer<typeof ProviderAccountsSchema>;
+export declare const ProviderAccountsSavePayloadSchema: z.ZodObject<{
+    accounts: z.ZodRecord<z.ZodString, z.ZodObject<{
+        kind: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        home: z.ZodOptional<z.ZodString>;
+        shadowHome: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            sensitive: z.ZodBoolean;
+            valueRedacted: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ProviderAccountsSavePayload = z.infer<typeof ProviderAccountsSavePayloadSchema>;
+export declare const ProviderAccountCreatePayloadSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        apple: "apple";
+        claude: "claude";
+        codex: "codex";
+        copilot: "copilot";
+        gemini: "gemini";
+    }>;
+    label: z.ZodString;
+    color: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ProviderAccountCreatePayload = z.infer<typeof ProviderAccountCreatePayloadSchema>;
+export declare const ProviderAccountCreateResultSchema: z.ZodObject<{
+    accounts: z.ZodRecord<z.ZodString, z.ZodObject<{
+        kind: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        home: z.ZodOptional<z.ZodString>;
+        shadowHome: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodString;
+            sensitive: z.ZodBoolean;
+            valueRedacted: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    statuses: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodString;
+        state: z.ZodEnum<{
+            checking: "checking";
+            disabled: "disabled";
+            failed: "failed";
+            "folder-missing": "folder-missing";
+            "not-found": "not-found";
+            ready: "ready";
+            "signed-out": "signed-out";
+            unavailable: "unavailable";
+        }>;
+        email: z.ZodNullable<z.ZodString>;
+        plan: z.ZodNullable<z.ZodString>;
+        organization: z.ZodNullable<z.ZodString>;
+        home: z.ZodString;
+        transcripts: z.ZodOptional<z.ZodString>;
+        message: z.ZodNullable<z.ZodString>;
+        checkedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    secretsAvailable: z.ZodOptional<z.ZodBoolean>;
+    loginCommands: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+        apple: "apple";
+        claude: "claude";
+        codex: "codex";
+        copilot: "copilot";
+        gemini: "gemini";
+    }> & z.core.$partial, z.ZodString>>;
+    id: z.ZodString;
+}, z.core.$strip>;
+export type ProviderAccountCreateResult = z.infer<typeof ProviderAccountCreateResultSchema>;
+export declare const ProviderAccountWatchLoginPayloadSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type ProviderAccountWatchLoginPayload = z.infer<typeof ProviderAccountWatchLoginPayloadSchema>;

package/dist/provider-accounts.js

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+import { AgentKindSchema } from './agent.js';
+/*
+ * An account of an agent CLI is one config folder of that CLI, handed to it through the variable it
+ * reads its folder from. The person signs in with the CLI itself; the daemon only asks the CLI who
+ * that is. Accounts belong to one host and live in its provider account store.
+ */
+/* A slug, never a path. The default account of a CLI has the CLI's kind as its id. */
+export const ProviderAccountIdSchema = z.string().regex(/^[a-z][a-z0-9_-]{0,63}$/);
+/*
+ * A variable the CLI of an account is started with. A sensitive value lives in the keychain of the
+ * machine and never on the wire: the daemon sends it as an empty `value` with `valueRedacted`, and a
+ * save that sends that back keeps what the keychain holds.
+ */
+export const ProviderAccountVariableSchema = z.object({
+    name: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/),
+    value: z.string(),
+    sensitive: z.boolean(),
+    valueRedacted: z.boolean().optional()
+});
+export const ProviderAccountSchema = z.object({
+    // An agent kind. A kind this version does not know still parses, so the entry is written back unchanged.
+    kind: z.string().min(1),
+    label: z.string().optional(),
+    // A node accent name (`NODE_ACCENT_NAMES`), kept a plain string so an older name is written back; the client paints any other with its accent.
+    color: z.string().optional(),
+    // Absent is on. An account that is off is left out of every picker.
+    enabled: z.boolean().optional(),
+    // The CLI's config folder, `~` allowed. Absent on the default account, which uses the CLI's own folder.
+    home: z.string().min(1).optional(),
+    // Codex only: a folder of its own for the login, sharing everything else with `home`.
+    shadowHome: z.string().min(1).optional(),
+    // Set on the CLI's environment after the login variables are taken off, so a key here is one a person chose.
+    env: z.array(ProviderAccountVariableSchema).optional()
+});
+export const ProviderAccountStateSchema = z.enum([
+    'checking',
+    'disabled',
+    // The CLI is not installed on this machine.
+    'not-found',
+    'signed-out',
+    'ready',
+    'folder-missing',
+    // A kind this version does not know, or a CLI with no variable for its config folder.
+    'unavailable',
+    'failed'
+]);
+/* What the CLI said about an account the last time it was asked. Never stored: the CLI is the truth. */
+export const ProviderAccountStatusSchema = z.object({
+    id: ProviderAccountIdSchema,
+    kind: z.string(),
+    state: ProviderAccountStateSchema,
+    email: z.string().nullable(),
+    plan: z.string().nullable(),
+    organization: z.string().nullable(),
+    // The folder the CLI is started with, resolved; empty for a CLI without a config folder variable.
+    home: z.string(),
+    // Where the account's conversations are written, resolved: a chat goes on under another account only when both write here.
+    transcripts: z.string().optional(),
+    // Why the state is what it is, in a sentence, when the CLI or the daemon said.
+    message: z.string().nullable(),
+    // Milliseconds since the epoch; 0 while the account was never checked.
+    checkedAt: z.number()
+});
+export const ProviderAccountMapSchema = z.record(ProviderAccountIdSchema, ProviderAccountSchema);
+export const ProviderAccountsSchema = z.object({
+    accounts: ProviderAccountMapSchema,
+    statuses: z.array(ProviderAccountStatusSchema),
+    // Whether this machine can keep a sensitive variable; false off macOS, where no keychain is used.
+    secretsAvailable: z.boolean().optional(),
+    // Per agent kind, what a terminal types to sign that CLI in under an account, which the account's environment points at.
+    loginCommands: z.partialRecord(AgentKindSchema, z.string()).optional()
+});
+/* The whole map: an id left out is removed, and its folder stays where it is. */
+export const ProviderAccountsSavePayloadSchema = z.object({
+    accounts: ProviderAccountMapSchema
+});
+/* An account in a folder the daemon makes for it under its account data directory; a Codex one is a shadow home over the CLI's own folder. */
+export const ProviderAccountCreatePayloadSchema = z.object({
+    kind: AgentKindSchema,
+    label: z.string().trim().min(1).max(80),
+    color: z.string().optional()
+});
+export const ProviderAccountCreateResultSchema = ProviderAccountsSchema.extend({
+    // The id the daemon minted from the label.
+    id: ProviderAccountIdSchema
+});
+/* Asks the CLI of one account again every few seconds until it is signed in, for a login running in a terminal. */
+export const ProviderAccountWatchLoginPayloadSchema = z.object({
+    id: ProviderAccountIdSchema
+});

package/dist/task.d.ts

@@ -0,0 +1,110 @@
+import { z } from 'zod';
+export declare const TaskStatusSchema: z.ZodEnum<{
+    cancelled: "cancelled";
+    done: "done";
+    failed: "failed";
+    open: "open";
+}>;
+export type TaskStatus = z.infer<typeof TaskStatusSchema>;
+export declare const TaskResultSchema: z.ZodObject<{
+    text: z.ZodString;
+    source: z.ZodEnum<{
+        done: "done";
+        exit: "exit";
+        turn: "turn";
+    }>;
+    at: z.ZodNumber;
+}, z.core.$strip>;
+export type TaskResult = z.infer<typeof TaskResultSchema>;
+export declare const TaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    projectId: z.ZodString;
+    parentId: z.ZodString;
+    childId: z.ZodString;
+    title: z.ZodString;
+    prompt: z.ZodString;
+    batchId: z.ZodOptional<z.ZodString>;
+    requiresTaskTurn: z.ZodOptional<z.ZodBoolean>;
+    background: z.ZodOptional<z.ZodObject<{
+        turnId: z.ZodString;
+        itemIds: z.ZodArray<z.ZodString>;
+        commands: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        done: "done";
+        failed: "failed";
+        open: "open";
+    }>;
+    result: z.ZodNullable<z.ZodObject<{
+        text: z.ZodString;
+        source: z.ZodEnum<{
+            done: "done";
+            exit: "exit";
+            turn: "turn";
+        }>;
+        at: z.ZodNumber;
+    }, z.core.$strip>>;
+    createdAt: z.ZodNumber;
+    settledAt: z.ZodNullable<z.ZodNumber>;
+    wake: z.ZodEnum<{
+        none: "none";
+        pending: "pending";
+        sent: "sent";
+    }>;
+    paused: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            overload: "overload";
+            usage: "usage";
+        }>;
+        until: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Task = z.infer<typeof TaskSchema>;
+export declare const TaskChangedEventSchema: z.ZodObject<{
+    task: z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodString;
+        parentId: z.ZodString;
+        childId: z.ZodString;
+        title: z.ZodString;
+        prompt: z.ZodString;
+        batchId: z.ZodOptional<z.ZodString>;
+        requiresTaskTurn: z.ZodOptional<z.ZodBoolean>;
+        background: z.ZodOptional<z.ZodObject<{
+            turnId: z.ZodString;
+            itemIds: z.ZodArray<z.ZodString>;
+            commands: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            done: "done";
+            failed: "failed";
+            open: "open";
+        }>;
+        result: z.ZodNullable<z.ZodObject<{
+            text: z.ZodString;
+            source: z.ZodEnum<{
+                done: "done";
+                exit: "exit";
+                turn: "turn";
+            }>;
+            at: z.ZodNumber;
+        }, z.core.$strip>>;
+        createdAt: z.ZodNumber;
+        settledAt: z.ZodNullable<z.ZodNumber>;
+        wake: z.ZodEnum<{
+            none: "none";
+            pending: "pending";
+            sent: "sent";
+        }>;
+        paused: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                overload: "overload";
+                usage: "usage";
+            }>;
+            until: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type TaskChangedEvent = z.infer<typeof TaskChangedEventSchema>;

package/dist/task.js

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export const TaskStatusSchema = z.enum(['open', 'done', 'failed', 'cancelled']);
+export const TaskResultSchema = z.object({
+    text: z.string(),
+    // How the result came about: the child called `done`, its first turn ended, or its process left.
+    source: z.enum(['done', 'turn', 'exit']),
+    at: z.number()
+});
+/*
+ * What a chat asked of a node it opened with `--task`, kept by the host under its data folder rather
+ * than anywhere an agent can write: waking the parent is a promise the host keeps.
+ */
+export const TaskSchema = z.object({
+    id: z.string().min(1),
+    projectId: z.string().min(1),
+    parentId: z.string().min(1),
+    childId: z.string().min(1),
+    title: z.string(),
+    prompt: z.string(),
+    // The one `team --task` call it came from: the parent is woken about that call once every task of it settled.
+    batchId: z.string().min(1).optional(),
+    requiresTaskTurn: z.boolean().optional(),
+    background: z.object({ turnId: z.string(), itemIds: z.array(z.string()), commands: z.array(z.string()) }).optional(),
+    status: TaskStatusSchema,
+    result: TaskResultSchema.nullable(),
+    createdAt: z.number(),
+    settledAt: z.number().nullable(),
+    // Whether the parent has been woken about this task yet; `none` for a task that never wakes anybody.
+    wake: z.enum(['pending', 'sent', 'none']),
+    // Set while the child's last turn stopped on a limit: the task stays open and wakes nobody, `until` the limit lifts when known.
+    paused: z.object({ kind: z.enum(['usage', 'overload']), until: z.number().optional() }).optional()
+});
+export const TaskChangedEventSchema = z.object({ task: TaskSchema });

package/dist/text.d.ts

@@ -0,0 +1 @@
+export declare function clipText(text: string, max: number): string;

package/dist/text.js

@@ -0,0 +1,19 @@
+const graphemes = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+/*
+ * The longest start of `text` that fits in `max` UTF-16 units, the measure a schema's `max` counts in,
+ * cut only between characters as a person sees them. A cut between the halves of a surrogate pair
+ * leaves a lone half, which JSON writes as an escape the iPhone app refuses along with its whole frame.
+ */
+export function clipText(text, max) {
+    if (text.length <= max) {
+        return text;
+    }
+    let end = 0;
+    for (const { segment } of graphemes.segment(text)) {
+        if (end + segment.length > max) {
+            break;
+        }
+        end += segment.length;
+    }
+    return text.slice(0, end);
+}