@intentic/sandbox-contract 1.247.0 → 1.249.0

package/dist/events.js

@@ -1,725 +0,0 @@
-import { z } from "zod";
-import { AgentHarnessSchema, AgentProviderSchema, PermissionModeSchema } from "./schemas/agent.js";
-import { AgentSummarySchema, LandConflictSchema } from "./schemas/agents.js";
-import { RateLimitInfoSchema } from "./schemas/claude-gate.js";
-import { FastModeStateSchema } from "./schemas/fast-mode.js";
-import { AccountUsageSchema, AgentReplySchema, ProviderRefusalSchema, UsageWindowSchema } from "./schemas/plan-limits.js";
-import { CredentialGateKindSchema, CredentialGateScopeSchema, CredentialLaneSchema } from "./schemas/secrets.js";
-import { ShareDetailSchema } from "./schemas/share.js";
-import { MemberRoleSchema } from "./schemas/shared.js";
-import { SubagentKindSchema, SubagentStatusSchema, SubagentVerificationSchema } from "./schemas/terminal.js";
-export const AskOptionSchema = z.object({
-    label: z.string().describe("The choice, in a few words."),
-    description: z.string().describe("What picking it means."),
-    preview: z.string().optional().describe("Something to look at while deciding: a mock-up, a snippet, a layout."),
-});
-export const AskQuestionSchema = z.object({
-    question: z.string().describe("What the agent is asking."),
-    header: z.string().describe("A short label for the question."),
-    multiSelect: z.boolean().describe("Whether more than one answer can be picked."),
-    options: z.array(AskOptionSchema).describe("The choices offered. A free-text answer is always possible as well."),
-});
-export const ProgramAskSchema = z.object({
-    text: z.string().describe("What would run."),
-    language: z.enum(["bash", "javascript"]).describe("Which of the two backends it is written for, named as the grammar that colours it."),
-    truncated: z
-        .boolean()
-        .describe("Whether this is an excerpt of a longer program, so the card can say so instead of ending mid-word. An excerpt always carries the flagged fragment: the beginning, then a window around the fragment, with any skipped middle written into the text as a bracketed count."),
-    spans: z
-        .array(z.object({ start: z.number().int().nonnegative(), end: z.number().int().nonnegative() }))
-        .describe("Which fragments of the text the pattern match fired on: every matched class's, or, under the hard rule, only the class the title names. Offsets into text, in order, never overlapping."),
-});
-export const PermissionAskSchema = z.object({
-    toolName: z.string().describe("Which tool it wants to use."),
-    title: z.string().optional().describe("The whole question, as a sentence, exactly as the runtime words it."),
-    displayName: z.string().optional().describe("A short phrase for the button, such as read file."),
-    description: z.string().optional().describe("More about what it is asking for."),
-    reason: z.string().optional().describe("Why it is asking at all: a rule, the current mode, something that looked risky."),
-    path: z.string().optional().describe("Which file it concerns, when it concerns one."),
-    alwaysLabel: z
-        .string()
-        .optional()
-        .describe("The wording for an always-allow answer. Present only when there is something an always could actually remember; without it the only answers are once and no."),
-    program: ProgramAskSchema.optional().describe("The program this card is holding, when the card is about one. Present on a command gate's card and absent on every other permission ask."),
-    explain: z
-        .string()
-        .optional()
-        .describe("One plain sentence saying what the program does and why it is being asked about, where the title says something else. Written by the judge that read your safety policy, never by the agent being gated."),
-});
-export const ServiceOfferSchema = z.object({
-    slug: z.string().describe("Which service."),
-    name: z.string().describe("What it is called."),
-    publisher: z.string().describe("Who runs it."),
-    description: z.string().describe("What it does."),
-    creditsPerRun: z
-        .number()
-        .describe("What one run costs. Stated by the platform rather than by the agent asking, which is what makes the price impossible to misquote."),
-    probation: z
-        .boolean()
-        .optional()
-        .describe("The listing is new and has not yet served enough runs cleanly to be trusted. The honest form of listed automatically but not vouched for, and the person approving the spend is who should know it."),
-    credits: z
-        .object({
-        allowance: z.number().describe("How many credits the period gives."),
-        remaining: z.number().describe("How many are left."),
-        resetsAt: z.string().describe("When they refill."),
-    })
-        .optional()
-        .describe("Your own meter, as the platform stated it."),
-    request: z.string().describe("Exactly what would be sent, so you can see what leaves before agreeing to it."),
-    why: z.string().optional().describe("The agent's case for spending, and the only words on this card that are the agent's."),
-});
-export const ServiceStreamEventSchema = z.discriminatedUnion(`event`, [
-    z.object({
-        event: z.literal(`status`).describe("Progress. Each one replaces the last: a label, not a log."),
-        text: z.string().describe("What it is doing."),
-    }),
-    z.object({
-        event: z.literal(`result`).describe("The answer. Exactly one of these ends a run."),
-        data: z.unknown().describe("The answer itself, in whatever shape that service returns."),
-    }),
-]);
-export const CapabilityOfferSchema = z.object({
-    card: z.string().describe("Which connection is being asked for."),
-    name: z.string().describe("What it is called, as the catalogue titles it rather than as the agent named it."),
-    why: z.string().optional().describe("The agent's case for connecting it, and the only words on this card that are the agent's."),
-});
-export const ServiceRunReceiptSchema = z.object({
-    event: z
-        .literal(`receipt`)
-        .describe("The last line of a run, added by the platform rather than by the service. The ledger speaking after the fact."),
-    outcome: z.enum([`ok`, `refunded`]).describe("Whether it served and was charged, or died before answering and the charge was reversed."),
-    credits: z.number().describe("What it cost."),
-    remaining: z.number().optional().describe("What is left afterwards."),
-});
-export const PaymentOfferSchema = z.object({
-    url: z.string().describe("What is being paid for."),
-    description: z.string().optional().describe("What the endpoint says it is."),
-    payTo: z.string().describe("Where the money goes, taken verbatim from the endpoint's own demand."),
-    network: z.string().describe("On which network."),
-    asset: z.string().describe("In which token."),
-    assetName: z.string().describe("That token's name. It is pegged to the dollar, which is what lets every amount here read as dollars."),
-    amountUsd: z.string().describe("The exact price. Not a ceiling: this scheme has no ranges, so this is the whole spend."),
-    spentTodayUsd: z.string().describe("What has already gone out today."),
-    dailyCapUsd: z.string().describe("What may go out in a day."),
-    why: z.string().optional().describe("The agent's case for paying, and the only words on this card that are the agent's."),
-});
-export const CredentialOfferSchema = z.object({
-    subject: z.string().describe("Which credential is being asked for."),
-    kind: CredentialGateKindSchema,
-    lane: CredentialLaneSchema,
-    detail: z
-        .string()
-        .optional()
-        .describe("Where it would go: the start of the command, the site, or what is being mounted. Never a value: the command still reads as a reference at this point."),
-    why: z.string().optional().describe("The agent's case for using it, and the only words on this card that are the agent's."),
-    approvers: z.array(z.string()).describe("Who may release it. A click from anyone else is refused and leaves the card standing."),
-    scope: CredentialGateScopeSchema,
-});
-export const AgentCommandSchema = z.object({
-    name: z.string().describe("What to type, without the leading slash."),
-    description: z.string().describe("What it does."),
-    hint: z.string().optional().describe("What its argument should look like, shown after the name."),
-});
-export const AgentCommandsQuerySchema = z.object({
-    agent: AgentProviderSchema.optional().describe("Whose commands to read. Leave it out for Claude."),
-});
-export const AgentCommandsSchema = z.object({
-    commands: z.array(AgentCommandSchema).describe("The shortcut commands, as the provider last published them."),
-});
-export const TodoItemSchema = z.object({
-    content: z.string().describe("The item, as the agent wrote it."),
-    status: z.enum(["pending", "in_progress", "completed"]).describe("Where it is."),
-    activeForm: z
-        .string()
-        .optional()
-        .describe("How to phrase it while it is happening, so a screen can say what the agent is doing rather than what it plans to do."),
-});
-export const ContextUsageSchema = z.object({
-    tokens: z.number().describe("How much the latest request sent, all told."),
-    contextWindow: z.number().describe("How much the model can hold. The gap between these two is how close the conversation is to being compacted."),
-});
-export const ToolKindSchema = z.enum(["read", "edit", "delete", "move", "search", "execute", "think", "fetch", "other"]);
-export const ToolCallStatusSchema = z.enum(["pending", "in_progress", "completed", "failed"]);
-export const ToolCallLocationSchema = z.object({
-    path: z.string().describe("The file, as a workspace path, whatever directory the tool was run from."),
-    line: z.number().optional().describe("Which line, counting from one."),
-});
-export const ToolCallContentSchema = z.discriminatedUnion("type", [
-    z.object({
-        type: z.literal("text").describe("Plain output."),
-        text: z.string().describe("What the tool said."),
-    }),
-    z.object({
-        type: z.literal("diff").describe("A change to a file."),
-        path: z.string().describe("Which file, as a workspace path."),
-        oldText: z.string().optional().describe("What was there. Absent for a new file, or where the previous contents are not known."),
-        newText: z.string().describe("What is there now."),
-        truncated: z.boolean().optional().describe("One of the two sides was too large to send whole."),
-    }),
-    z.object({
-        type: z.literal("image").describe("A picture the tool produced."),
-        path: z
-            .string()
-            .describe("Where it is, as a workspace path. A path rather than the bytes, because the workspace already serves it, sending it inline would bloat every stored record, and this way the picture stays openable afterwards."),
-    }),
-]);
-export const CardDocumentSchema = z.object({
-    path: z.string().describe("Where it lives, as a workspace path."),
-    title: z.string().describe("What it is called: its opening heading, or its file name."),
-    markdown: z.string().describe("The document itself."),
-    truncated: z.boolean().optional().describe("It was clipped at the wire cap; the file on disk has more."),
-    plan: z.boolean().optional().describe("It is one of the CLI's plan files, written to be approved rather than merely read."),
-});
-const REQUEST_ID = z.string().describe("What to send back when you answer.");
-const planCard = {
-    requestId: REQUEST_ID,
-    text: z.string().describe("The plan itself."),
-    document: CardDocumentSchema.optional().describe("The write-up this plan refers to, when the plan itself is a pointer to one."),
-};
-const questionCard = {
-    requestId: REQUEST_ID,
-    questions: z.array(AskQuestionSchema).describe("What it wants to know."),
-    document: CardDocumentSchema.optional().describe("The document this turn wrote and is asking about, so the choice can be read beside it."),
-};
-const permissionCard = { requestId: REQUEST_ID };
-const browserHelpCard = {
-    requestId: z.string(),
-    session: z.string(),
-    account: z.string(),
-    message: z.string(),
-};
-const terminalHelpCard = {
-    requestId: z.string(),
-    session: z.string(),
-    message: z.string(),
-};
-const serviceOfferCard = { requestId: z.string(), offer: ServiceOfferSchema };
-const capabilityOfferCard = { requestId: z.string(), offer: CapabilityOfferSchema };
-const paymentOfferCard = { requestId: z.string(), offer: PaymentOfferSchema };
-const credentialOfferCard = { requestId: z.string(), offer: CredentialOfferSchema };
-export const ServiceReceiptSchema = z.object({
-    outcome: z.enum(["ok", "refunded", "refused"]),
-    credits: z.number(),
-    remaining: z.number().optional(),
-});
-export const CapabilityOutcomeSchema = z.object({
-    outcome: z.enum(["connected", "unfinished"]),
-    id: z.string().optional(),
-});
-export const PaymentReceiptSchema = z.object({
-    outcome: z.enum(["paid", "failed"]),
-    amountUsd: z.string(),
-    transaction: z.string().optional(),
-    network: z.string().optional(),
-});
-export const CredentialReceiptSchema = z.object({
-    outcome: z.enum(["released", "refused"]),
-    approvedBy: z.string().optional(),
-});
-const PlanCardSchema = z.object({
-    kind: z.literal("plan").describe("The agent has written a plan and is waiting for a yes."),
-    ...planCard,
-});
-const QuestionCardSchema = z.object({
-    kind: z.literal("question").describe("The agent has asked you something and is waiting."),
-    ...questionCard,
-});
-const PermissionCardSchema = PermissionAskSchema.extend({
-    kind: z.literal("permission").describe("The agent wants to use a tool it needs permission for."),
-    ...permissionCard,
-});
-export const ParkedCardSchema = z.discriminatedUnion("kind", [PlanCardSchema, QuestionCardSchema, PermissionCardSchema]);
-export const PlanStatusSchema = z.enum(["pending", "approved", "rejected", "cancelled"]);
-export const QuestionStatusSchema = z.enum(["pending", "answered", "cancelled"]);
-export const PermissionStatusSchema = z.enum(["pending", "allowed", "always", "denied", "cancelled"]);
-export const HelpStatusSchema = z.enum(["pending", "helped", "declined", "cancelled"]);
-export const OfferStatusSchema = z.enum(["pending", "approved", "skipped", "cancelled"]);
-export const CapabilityOfferStatusSchema = z.enum(["pending", "connecting", "skipped", "cancelled"]);
-export const TranscriptPlanSchema = z.object({ ...planCard, status: PlanStatusSchema.describe("Where the decision stands.") });
-export const TranscriptQuestionSchema = z.object({
-    ...questionCard,
-    status: QuestionStatusSchema.describe("Where the answer stands."),
-    answers: z
-        .record(z.string(), z.array(z.string()))
-        .optional()
-        .describe("What was chosen, keyed by the question, with the chosen labels or the user's own words."),
-});
-export const TranscriptPermissionSchema = PermissionAskSchema.extend({ ...permissionCard, status: PermissionStatusSchema.describe("Where the decision stands.") });
-export const TranscriptBrowserHelpSchema = z.object({ ...browserHelpCard, status: HelpStatusSchema.describe("How the hand-over ended.") });
-export const TranscriptTerminalHelpSchema = z.object({ ...terminalHelpCard, status: HelpStatusSchema.describe("How the hand-over ended.") });
-export const TranscriptServiceOfferSchema = z.object({
-    ...serviceOfferCard,
-    status: OfferStatusSchema.describe("Where the decision stands."),
-    events: z.array(ServiceStreamEventSchema).optional().describe("The approved run's stream, in order (the service_event frames)."),
-    receipt: ServiceReceiptSchema.optional().describe("How the approved run ended (the service_receipt frame)."),
-});
-export const TranscriptCapabilityOfferSchema = z.object({
-    ...capabilityOfferCard,
-    status: CapabilityOfferStatusSchema.describe("Where the decision stands."),
-    outcome: CapabilityOutcomeSchema.optional().describe("How an accepted ask's setup ended (the capability_outcome frame)."),
-});
-export const TranscriptPaymentOfferSchema = z.object({
-    ...paymentOfferCard,
-    status: OfferStatusSchema.describe("Where the decision stands."),
-    receipt: PaymentReceiptSchema.optional().describe("How the approved payment ended (the payment_receipt frame)."),
-});
-export const TranscriptCredentialOfferSchema = z.object({
-    ...credentialOfferCard,
-    status: OfferStatusSchema.describe("Where the decision stands."),
-    receipt: CredentialReceiptSchema.optional().describe("Who released it, or that somebody refused (the credential_receipt frame)."),
-});
-export const TranscriptToolSchema = z.lazy(() => z.object({
-    id: z.string().describe("The call's id."),
-    name: z.string().describe("Which tool."),
-    category: ToolKindSchema.describe("What kind of thing it does: read, edit, delete, move, search, run, think, fetch. Named the same way whatever the backend called the tool."),
-    status: ToolCallStatusSchema.describe("How it went."),
-    target: z.string().optional().describe("What it acted on, in one line: a file, a command, an address."),
-    locations: z.array(ToolCallLocationSchema).optional().describe("The files it touched."),
-    content: z.array(ToolCallContentSchema).optional().describe("What it produced: text, a change to a file, or a picture."),
-    children: z
-        .array(TranscriptToolSchema)
-        .optional()
-        .describe("Calls a delegated subagent made, nested under the call that started it, so a reopened conversation redraws the delegation rather than collapsing it into one result."),
-    thinking: z.string().optional().describe("What the agent was reasoning about around this call."),
-    subagent: TranscriptSubagentSchema.optional().describe("The helper this call started, as the daemon's registry sees it: what it is, how it is going, what it has spent. What a card can say about a backgrounded child whose result is minutes away."),
-}));
-export const TranscriptSubagentSchema = z.object({
-    kind: SubagentKindSchema,
-    agentType: z.string().optional(),
-    description: z.string().optional(),
-    model: z.string().optional(),
-    provider: z.string().optional(),
-    background: z.boolean().optional(),
-    status: SubagentStatusSchema,
-    tokens: z.number().optional(),
-    toolUses: z.number().optional(),
-    lastTool: z.string().optional(),
-    summary: z.string().optional(),
-    error: z.string().optional(),
-    verification: SubagentVerificationSchema.optional(),
-});
-export const TurnNoteSchema = z.object({
-    title: z.string().describe("The one line a reader sees, on a row that opens to the text below."),
-    text: z.string().describe("The note itself, which is also exactly what the model was told."),
-});
-export const TranscriptUsageSchema = z.object({
-    costUsd: z.number().optional(),
-    inputTokens: z.number().optional(),
-    outputTokens: z.number().optional(),
-    durationMs: z.number().optional(),
-    numTurns: z.number().optional(),
-});
-export const TranscriptRowSchema = z.object({
-    role: z
-        .enum(["user", "assistant", "notice"])
-        .describe("Who said it. A notice is neither side: it is something that happened to the turn, recorded so a reopened conversation can say it. Without those, a turn a provider refused ends on the user's message and reads as broken."),
-    text: z.string().describe("The words."),
-    sentAt: z
-        .number()
-        .optional()
-        .describe("When it was sent, in milliseconds. On the user's rows only, because that is the only moment actually known: a turn's own frames arrive with no clock, so stamping the agent's rows could only ever mean the whole turn's start or end."),
-    attachments: z.array(z.string()).optional().describe("Files attached to this message, as workspace paths."),
-    checkpointId: z
-        .string()
-        .optional()
-        .describe("The saved point this message can be rewound to. Looked up on each read rather than stored, so what is offered is exactly what is still there to go back to."),
-    rewindIndex: z
-        .number()
-        .int()
-        .nonnegative()
-        .optional()
-        .describe("This message's position in the conversation's record, which is how a rewind names it. Present only beside a checkpoint."),
-    thinking: z.string().optional().describe("What the agent was reasoning about."),
-    tools: z.array(TranscriptToolSchema).optional().describe("The tool calls this part of the turn made."),
-    todos: z.array(TodoItemSchema).optional().describe("The agent's task checklist, as of this bubble."),
-    usage: TranscriptUsageSchema.optional().describe("What the turn cost, on the bubble its answer ended in."),
-    notes: z
-        .array(TurnNoteSchema)
-        .optional()
-        .describe("What the sandbox added to this message before the model saw it. Carried on the message rather than as rows of their own, because they genuinely were part of what was sent."),
-    placed: z
-        .boolean()
-        .optional()
-        .describe("A person wrote this in the agent's voice, with no turn behind it. Marked for the human re-reading the conversation months later, so their own words do not pass as the agent's. The agent itself never sees the mark."),
-    noticeAction: z
-        .enum(["landHold", "outageOptOut", "depsInstall", "tierHold"])
-        .optional()
-        .describe("A one-press follow-up this notice offers, by name. The chat decides what it does and whether it still applies."),
-    noticeWait: z.enum(["credentialRenewal"]).optional().describe("The wait this notice describes, by name, so a reader can say whether it is still on."),
-    plan: TranscriptPlanSchema.optional().describe("The plan this row asked approval for, and the answer."),
-    question: TranscriptQuestionSchema.optional().describe("The questions this row asked, and the picks that answered them."),
-    permission: TranscriptPermissionSchema.optional().describe("The tool this row asked permission for, and the decision."),
-    browserHelp: TranscriptBrowserHelpSchema.optional().describe("The browser hand-over this row asked for, and how it ended."),
-    terminalHelp: TranscriptTerminalHelpSchema.optional().describe("The terminal hand-over this row asked for, and how it ended."),
-    serviceOffer: TranscriptServiceOfferSchema.optional().describe("The priced service run this row offered, the decision, and the receipt."),
-    capabilityOffer: TranscriptCapabilityOfferSchema.optional().describe("The capability setup this row asked for, the decision, and the outcome."),
-    paymentOffer: TranscriptPaymentOfferSchema.optional().describe("The payment this row asked for, the decision, and the receipt."),
-    credentialOffer: TranscriptCredentialOfferSchema.optional().describe("The gated credential this row asked to use, who may release it, and who did."),
-});
-export const CARD_FIELDS = [
-    "plan",
-    "question",
-    "permission",
-    "browserHelp",
-    "terminalHelp",
-    "serviceOffer",
-    "capabilityOffer",
-    "paymentOffer",
-    "credentialOffer",
-];
-export const holdsCard = (row) => CARD_FIELDS.some((field) => row[field] !== undefined);
-export const isAwaitingDecision = (row) => CARD_FIELDS.some((field) => row[field]?.status === "pending");
-export const TranscriptPatchSchema = z.discriminatedUnion("op", [
-    z.object({ op: z.literal("append").describe("A new row at the end."), row: TranscriptRowSchema }),
-    z.object({ op: z.literal("replace").describe("This row, whole, in place of the one at that index."), index: z.number().int().nonnegative(), row: TranscriptRowSchema }),
-    z.object({ op: z.literal("drop").describe("The row at that index is gone: it was opened and never written into."), index: z.number().int().nonnegative() }),
-    z.object({ op: z.literal("text").describe("More of the agent's prose, onto that row's text."), index: z.number().int().nonnegative(), text: z.string() }),
-    z.object({ op: z.literal("thinking").describe("More of the agent's reasoning, onto that row's thinking."), index: z.number().int().nonnegative(), text: z.string() }),
-    z.object({
-        op: z.literal("tool").describe("A tool card, whole: new, or the latest state of one already there, matched by id wherever it nests."),
-        index: z.number().int().nonnegative(),
-        tool: TranscriptToolSchema,
-        parent: z.string().optional().describe("The card this one nests under, when it is a delegated subagent's own call."),
-    }),
-]);
-export const SessionTranscriptSchema = z.object({
-    messages: z
-        .array(TranscriptRowSchema)
-        .describe("The conversation, in order. Each block of the agent's prose is its own message with the tools that block introduced, which is what reproduces the way it actually unfolded."),
-});
-export const TurnEndingSchema = z.object({
-    reason: z
-        .enum(["stopped", "limit", "outage"])
-        .describe("Which ending left the work here: a Stop or a daemon killed under the turn, a spent usage allowance, or a provider that refused it."),
-    resetsAt: z
-        .number()
-        .optional()
-        .describe("When the spent allowance reopens, in epoch seconds. Absent for every ending that names no instant, and for a provider that publishes none."),
-    held: z
-        .object({ ran: z.boolean().describe("Whether the held turn got anywhere before it was refused, which is a different sentence from one refused at the door.") })
-        .optional()
-        .describe("Present when the daemon still holds the refused turn whole, so a press re-runs it rather than appending a message after it."),
-    scheduled: z
-        .boolean()
-        .optional()
-        .describe("Whether something other than the user is already booked to send this turn again, so the surface reports the wait instead of offering a press."),
-});
-export const AgentTranscriptSchema = SessionTranscriptSchema.extend({
-    sessionId: z.string().optional().describe("The provider session behind the last turn, when there is one."),
-    provider: AgentProviderSchema.optional().describe("Which provider minted that session."),
-    harness: AgentHarnessSchema.optional().describe("Which runtime minted it: a session resumes only on the loop that opened it."),
-    account: z
-        .string()
-        .optional()
-        .describe("Which stored account it belongs to, as the daemon resolved it. Absent when no stored account paid for the turn."),
-    ending: TurnEndingSchema.optional().describe("How the last turn ended, when it left work behind that one press finishes. Absent for a conversation whose last turn ended on its own, and for the failures that name something to repair first."),
-    from: z.number().int().nonnegative().describe("Where the first message sits in the whole record, and the `before` that asks for the page above this one."),
-    more: z.boolean().describe("Whether older messages precede this page."),
-});
-export const SharePayloadSchema = z.object({
-    title: z.string(),
-    sharedAt: z.number(),
-    detail: ShareDetailSchema,
-    messages: z.array(TranscriptRowSchema),
-});
-export const AgentEventSchema = z.discriminatedUnion("kind", [
-    z.object({
-        kind: z.literal("session"),
-        sessionId: z.string(),
-        account: z.string().optional().describe("Which stored account this session belongs to, as the daemon resolved it for the turn."),
-    }),
-    z.object({
-        kind: z.literal("worktree"),
-        branch: z.string(),
-        base: z.string(),
-        unenforced: z.boolean().optional(),
-        sync: z.object({ commits: z.number(), blocked: z.array(z.string()) }).optional(),
-        remote: z.string().optional(),
-    }),
-    z.object({
-        kind: z.literal("landed"),
-        landed: z.boolean(),
-        conflicts: z.array(LandConflictSchema).optional(),
-        held: z.boolean().optional(),
-        deps: z.object({ missing: z.number(), started: z.array(z.string()), deferred: z.boolean() }).optional(),
-    }),
-    z.object({ kind: z.literal("preamble"), notes: z.array(TurnNoteSchema) }),
-    z.object({ kind: z.literal("init"), model: z.string() }),
-    z.object({ kind: z.literal("checkpoint"), id: z.string(), index: z.number().int().nonnegative().optional() }),
-    z.object({ kind: z.literal("steer"), text: z.string(), sentAt: z.number(), attachments: z.array(z.string()).optional() }),
-    z.object({ kind: z.literal("delta"), text: z.string(), parentToolUseId: z.string().optional() }),
-    z.object({ kind: z.literal("text_end"), parentToolUseId: z.string().optional() }),
-    z.object({ kind: z.literal("thinking"), text: z.string(), parentToolUseId: z.string().optional() }),
-    z.object({
-        kind: z.literal("tool_call"),
-        id: z.string(),
-        name: z.string(),
-        category: ToolKindSchema,
-        status: ToolCallStatusSchema,
-        target: z.string().optional(),
-        locations: z.array(ToolCallLocationSchema).optional(),
-        content: z.array(ToolCallContentSchema).optional(),
-        parentToolUseId: z.string().optional(),
-    }),
-    z.object({
-        kind: z.literal("tool_call_update"),
-        id: z.string(),
-        status: ToolCallStatusSchema.optional(),
-        content: z.array(ToolCallContentSchema).optional(),
-        locations: z.array(ToolCallLocationSchema).optional(),
-    }),
-    z.object({ kind: z.literal("terminal"), session: z.string() }),
-    z.object({ kind: z.literal("browser"), session: z.string() }),
-    z.object({
-        kind: z.literal("subagent"),
-        id: z.string(),
-        subagentKind: SubagentKindSchema,
-        agentType: z.string().optional(),
-        description: z.string().optional(),
-        model: z.string().optional(),
-        provider: z.string().optional(),
-        background: z.boolean().optional(),
-    }),
-    z.object({
-        kind: z.literal("subagent_update"),
-        id: z.string(),
-        status: SubagentStatusSchema.optional(),
-        tokens: z.number().optional(),
-        toolUses: z.number().optional(),
-        lastTool: z.string().optional(),
-        summary: z.string().optional(),
-        error: z.string().optional(),
-        verification: SubagentVerificationSchema.optional(),
-    }),
-    z.object({ kind: z.literal("todos"), items: z.array(TodoItemSchema) }),
-    z.object({ kind: z.literal("commands"), items: z.array(AgentCommandSchema) }),
-    z.object({
-        kind: z.literal("usage"),
-        account: z.string().optional(),
-        costUsd: z.number().optional(),
-        inputTokens: z.number().optional(),
-        outputTokens: z.number().optional(),
-        cacheReadTokens: z.number().optional(),
-        cacheCreationTokens: z.number().optional(),
-        durationMs: z.number().optional(),
-        numTurns: z.number().optional(),
-    }),
-    RateLimitInfoSchema.extend({ kind: z.literal("rate_limit_info"), account: z.string().optional() }),
-    z.object({
-        kind: z.literal("fast_mode"),
-        state: FastModeStateSchema,
-        reason: z.string().optional(),
-    }),
-    z.object({
-        kind: z.literal("tier"),
-        tier: z.enum(["fast", "standard"]),
-        score: z.number(),
-        rules: z.array(z.string()),
-        model: z.string().optional(),
-        routed: z.boolean(),
-        held: z.boolean().optional(),
-    }),
-    z.object({
-        kind: z.literal("provider_retry"),
-        attempt: z.number(),
-        maxAttempts: z.number().optional(),
-        nextAttemptAt: z.number().optional(),
-        status: z.number().optional(),
-    }),
-    z.object({ kind: z.literal("account_usage"), account: z.string().optional(), windows: z.array(UsageWindowSchema) }),
-    ContextUsageSchema.extend({ kind: z.literal("context_usage") }),
-    z.object({ kind: z.literal("compact"), trigger: z.string(), preTokens: z.number().optional(), postTokens: z.number().optional() }),
-    PlanCardSchema,
-    QuestionCardSchema,
-    PermissionCardSchema,
-    z.object({ kind: z.literal("browser_help"), ...browserHelpCard }),
-    z.object({ kind: z.literal("terminal_help"), ...terminalHelpCard }),
-    z.object({ kind: z.literal("service_offer"), ...serviceOfferCard }),
-    z.object({ kind: z.literal("service_event"), requestId: z.string(), event: ServiceStreamEventSchema }),
-    ServiceReceiptSchema.extend({ kind: z.literal("service_receipt"), requestId: z.string() }),
-    z.object({ kind: z.literal("capability_offer"), ...capabilityOfferCard }),
-    CapabilityOutcomeSchema.extend({ kind: z.literal("capability_outcome"), requestId: z.string() }),
-    z.object({ kind: z.literal("payment_offer"), ...paymentOfferCard }),
-    PaymentReceiptSchema.extend({ kind: z.literal("payment_receipt"), requestId: z.string() }),
-    z.object({ kind: z.literal("credential_offer"), ...credentialOfferCard }),
-    CredentialReceiptSchema.extend({ kind: z.literal("credential_receipt"), requestId: z.string() }),
-    z.object({ kind: z.literal("resolved"), requestId: z.string(), reply: AgentReplySchema.optional() }),
-    z.object({ kind: z.literal("mode"), mode: PermissionModeSchema }),
-    z.object({
-        kind: z.literal("error"),
-        message: z.string(),
-        code: z
-            .enum([
-            "session-not-found",
-            "rate_limit",
-            "codex-advisory",
-            "codex-reauth",
-            "claude-reauth",
-            "claude-token-refused",
-            "claude-not-entitled",
-            "provider-outage",
-            "trial-unavailable",
-            "trial-model-unavailable",
-            "trial-exhausted",
-            "unknown-command",
-            "grok-model-invalid",
-            "codex-model-invalid",
-            "model-unavailable",
-            "context-window-too-small",
-            "subscription-required",
-            "agent-busy",
-            "sandbox-memory-low",
-            "turn-cap",
-            "harness-incomplete",
-            "engine-version-floor",
-        ])
-            .optional(),
-        engine: z
-            .object({
-            id: z.string().describe("Which engine (e.g. claude)."),
-            running: z.string().optional().describe("The version that was refused, when the provider named it."),
-            floor: z.string().describe("The lowest version the provider will accept."),
-        })
-            .optional(),
-        resetsAt: z.number().optional(),
-        autoResume: z.enum(["scheduled", "available"]).optional(),
-        held: z.object({ ran: z.boolean() }).optional(),
-        outage: z.object({ retryAt: z.number(), attempt: z.number(), maxAttempts: z.number() }).optional(),
-    }),
-    z.object({ kind: z.literal("done") }),
-]);
-export const TURN_FACT_KINDS = [
-    "session",
-    "worktree",
-    "init",
-    "terminal",
-    "browser",
-    "commands",
-    "usage",
-    "rate_limit_info",
-    "fast_mode",
-    "tier",
-    "provider_retry",
-    "account_usage",
-    "context_usage",
-    "mode",
-    "error",
-];
-export const isTurnFact = (event) => TURN_FACT_KINDS.includes(event.kind);
-const factMembers = AgentEventSchema.options.filter((member) => TURN_FACT_KINDS.includes(member.shape.kind.value));
-export const TurnFactSchema = z.discriminatedUnion("kind", factMembers);
-export const AttachFrameSchema = z.discriminatedUnion("kind", [
-    z.object({
-        kind: z.literal("attached").describe("The first frame, identifying the run you have joined and handing you its transcript so far."),
-        run: z.string().describe("The run's id."),
-        startedAt: z.number().describe("When it started, in milliseconds, so a window joining late can show how long it has been going."),
-        seq: z.number().describe("How many frames the run has produced so far. A fact at or below this number is being replayed; a patch is never."),
-        rows: z
-            .array(TranscriptRowSchema)
-            .describe("The turn's rows as they stand: what was asked, and everything the agent has said and done since. Draw these, then apply the patches that follow."),
-    }),
-    z.object({
-        kind: z.literal("patch").describe("One change to the run's rows."),
-        seq: z.number().describe("Its position in the run, counting from one."),
-        patch: TranscriptPatchSchema,
-    }),
-    z.object({
-        kind: z.literal("fact").describe("One thing about the turn that is not a row: its session, its branch, its cost, a failure."),
-        seq: z.number().describe("Its position in the run, counting from one. At or below the head's number, it is being replayed."),
-        fact: TurnFactSchema,
-    }),
-    z.object({
-        kind: z
-            .literal("end")
-            .describe("The run is over and every frame has been delivered. A stream that closes without this was dropped mid-run, so re-attach rather than assuming the turn finished."),
-    }),
-]);
-const REPEATED = "The interrupted request is repeated below, where part of it was already completed in this session, continue from that point instead of starting over.";
-export const RESUME_NOTES = {
-    auth: `The Claude credential that interrupted this conversation has been renewed, and this turn resumed automatically. ${REPEATED}`,
-    outage: `The model provider was briefly unavailable and interrupted this conversation; this turn resumed automatically. ${REPEATED}`,
-    restart: `The sandbox restarted while this turn was running, which stopped it, and this turn resumed automatically once it came back. ${REPEATED}`,
-    limit: `The model provider's usage allowance ran out while this turn was running, which stopped it, and it has been sent again. ${REPEATED}`,
-    switched: "The model provider's usage allowance ran out while this turn was running, which stopped it, and it has been sent again on a different account, which starts a fresh session. The conversation so far has been carried across above, including the part of the request that was already completed: continue from that point instead of starting over.",
-    refused: "The model provider refused the previous attempt at this request outright, because its usage allowance was spent: no part of the request below was read or acted on, and nothing has been done towards it. It has been sent again, and starts from the beginning.",
-    answered: "The sandbox restarted while this conversation was waiting for the user to respond; it is back, and their response follows below: continue from where the session left off.",
-};
-export const withResumeNote = (prompt, note) => Object.values(RESUME_NOTES).some((known) => prompt.startsWith(known)) ? prompt : `${note}\n\n${prompt}`;
-export const withoutResumeNote = (prompt) => {
-    const note = Object.values(RESUME_NOTES).find((known) => prompt.startsWith(known));
-    return note === undefined ? prompt : prompt.slice(prompt.indexOf("\n\n") + 2);
-};
-const RESUME_DISCLOSURES = {
-    auth: { kind: "notice", text: "Claude sign-in renewed, this turn picked up where it left off." },
-    outage: { kind: "notice", text: "The model provider came back, this turn picked up where it left off." },
-    restart: { kind: "notice", text: "The sandbox came back, this turn picked up where it left off." },
-    limit: { kind: "notice", text: "Sent again after the allowance ran out mid-turn, picking up where it left off." },
-    switched: { kind: "notice", text: "Sent again on the switched account after the allowance ran out mid-turn, in a fresh session." },
-    refused: { kind: "notice", text: "Sent again after the allowance refused it: nothing had run." },
-    answered: { kind: "note", note: { title: "Picked back up after a sandbox restart", text: RESUME_NOTES.answered } },
-};
-export const resumeDisclosure = (prompt) => {
-    const reason = Object.keys(RESUME_NOTES).find((key) => prompt.startsWith(RESUME_NOTES[key]));
-    return reason === undefined ? undefined : RESUME_DISCLOSURES[reason];
-};
-export const IntenticLineSchema = z.looseObject({ kind: z.string() });
-export const HeartbeatSchema = z.object({ kind: z.literal("heartbeat") });
-export const BootStepSchema = z.object({
-    key: z.string(),
-    label: z.string(),
-    state: z.enum(["pending", "running", "done", "failed"]),
-    ms: z.number().optional(),
-});
-export const BootProgressSchema = z.object({
-    ready: z.boolean(),
-    startedAt: z.number(),
-    steps: z.array(BootStepSchema),
-});
-export const BootSchema = z.object({ kind: z.literal("boot"), ...BootProgressSchema.shape });
-export const HelloSchema = z.object({
-    kind: z.literal("hello"),
-    workspaceId: z.string(),
-    routes: z.array(z.string()).optional(),
-    shapes: z.record(z.string(), z.string()).optional(),
-    build: z.string().optional(),
-    boot: BootProgressSchema.optional(),
-});
-export const ReposChangedSchema = z.object({ kind: z.literal("reposChanged"), repos: z.array(z.string()) });
-export const WorkspaceChangedSchema = z.object({ kind: z.literal("workspaceChanged"), paths: z.array(z.string()) });
-export const RefsChangedSchema = z.object({ kind: z.literal("refsChanged"), repos: z.array(z.string()) });
-export const RuntimeChangedSchema = z.object({ kind: z.literal("runtimeChanged"), domains: z.array(z.string()) });
-export const PresenceUserSchema = z.object({
-    clientId: z.string(),
-    email: z.string(),
-    name: z.string().optional(),
-    picture: z.string().optional(),
-    role: MemberRoleSchema,
-    idle: z.boolean(),
-    view: z.string().optional(),
-    sessionId: z.string().optional(),
-    path: z.string().optional(),
-});
-export const PresenceSchema = z.object({ kind: z.literal("presence"), users: z.array(PresenceUserSchema) });
-export const AgentsSchema = z.object({ kind: z.literal("agents"), agents: z.array(AgentSummarySchema), rev: z.number() });
-export const AccountUsageChangedSchema = z.object({
-    kind: z.literal("accountUsage"),
-    provider: z.string(),
-    account: z.string(),
-    usage: AccountUsageSchema.optional(),
-});
-export const ProviderRefusalChangedSchema = z.object({ kind: z.literal("providerRefusal"), provider: z.string(), refusal: ProviderRefusalSchema.optional() });
-export const SystemEventSchema = z.discriminatedUnion("kind", [
-    HelloSchema,
-    HeartbeatSchema,
-    BootSchema,
-    WorkspaceChangedSchema,
-    ReposChangedSchema,
-    RefsChangedSchema,
-    RuntimeChangedSchema,
-    PresenceSchema,
-    AgentsSchema,
-    AccountUsageChangedSchema,
-    ProviderRefusalChangedSchema,
-]);
-//# sourceMappingURL=events.js.map