@intentic/sandbox-contract 1.232.0 → 1.234.0

package/src/hostnames.ts

@@ -14,7 +14,7 @@ export const sandboxHostname = (id: string, zone: string): string => `${sandboxS
 // The container sshd hostname the desktop-sync (Mutagen) reaches over the sandbox tunnel: `ssh-<id>.<zone>`.
 export const sshHostname = (id: string, zone: string): string => `ssh-${id}.${zone}`;
 
-/* The LOOPBACK name: `local-<id>.<zone>`, an A record pointing at 127.0.0.1.
+/* The LOOPBACK name: `<id>.local.<zone>`, resolving to 127.0.0.1 under ONE wildcard record for the whole zone.
  *
  * A public DNS name for a private address looks odd until you ask what the alternative is. A browser on the
  * same machine as the sandbox can reach its daemon in microseconds instead of crossing to a Cloudflare edge
@@ -23,9 +23,25 @@ export const sshHostname = (id: string, zone: string): string => `ssh-${id}.${zo
  * one; this can. The daemon holds the key and gets the certificate by proving control of the zone over
  * DNS-01 (there is nothing on the public internet for a CA to connect to).
  *
+ * IT IS A LABEL DEEPER THAN THE OTHER NAMES, and that is the entire point rather than a naming preference. A
+ * DNS wildcard matches ONE label, so `*.<zone>` cannot cover `<id>.local.<zone>` and `*.local.<zone>` covers
+ * every sandbox that will ever exist: one record for the platform, not one per sandbox. The shape it replaced,
+ * `local-<id>.<zone>`, needed a record each, and a zone has a hard per-record quota (Cloudflare 81045). Every
+ * OTHER per-sandbox record went away with the move to the zrok hub, so this was the last thing consuming that
+ * quota, and when the zone filled the platform could no longer write the record OR the ACME challenge beside
+ * it: the certified shortcut stopped resolving, every browser fell back to the plain-http loopback, and that
+ * transport is HTTP/1.1 with six connections per origin (see the editor's streamBudget.ts for what that cost).
+ * A quota nothing can exhaust is the fix that keeps working.
+ *
  * It discloses nothing: the id is already the leading label of the sandbox's public hostname, and the address
  * it resolves to is every machine's own loopback. */
-export const localHostname = (id: string, zone: string): string => `local-${id}.${zone}`;
+export const localHostname = (id: string, zone: string): string => `${id}.${LOCAL_LABEL}.${zone}`;
+
+// The label the loopback names live under, so the wildcard has something to be a wildcard OF.
+export const LOCAL_LABEL = "local";
+
+// The single record that answers for all of them. Never per-sandbox, never reaped.
+export const localWildcardHostname = (zone: string): string => `*.${LOCAL_LABEL}.${zone}`;
 
 // What that record points at, and the reason it is safe to publish: every resolver on earth gets 127.0.0.1.
 export const LOCAL_ADDRESS = "127.0.0.1";

package/src/index.ts

@@ -19,6 +19,7 @@ import { grokContract } from "./contracts/grok.contract.js";
 import { historyContract } from "./contracts/history.contract.js";
 import { intenticContract } from "./contracts/intentic.contract.js";
 import { inventoryContract } from "./contracts/inventory.contract.js";
+import { issuesContract } from "./contracts/issues.contract.js";
 import { logsContract } from "./contracts/logs.contract.js";
 import { loopsContract } from "./contracts/loops.contract.js";
 import { panelsContract } from "./contracts/panels.contract.js";
@@ -59,10 +60,14 @@ export { historyContract } from "./contracts/history.contract.js";
 /* Deliberately NOT part of `sandboxContract` below: that map is the daemon's own HTTP surface, and this one is
  * spoken the other way round, over a connected computer's WebSocket, with the MACHINE implementing it. */
 export { hostContract } from "./contracts/host.contract.js";
+// The same inversion again, one layer in: spoken over the socket a BROWSER EXTENSION opened, with the
+// extension implementing it (contracts/webext.contract.ts).
+export { webextContract } from "./contracts/webext.contract.js";
 // Same inversion, other direction of trust: spoken over a RUNNER's WebSocket, with the runner implementing it.
 export { runnerContract } from "./contracts/runner.contract.js";
 export { intenticContract } from "./contracts/intentic.contract.js";
 export { inventoryContract } from "./contracts/inventory.contract.js";
+export { issuesContract } from "./contracts/issues.contract.js";
 export { logsContract } from "./contracts/logs.contract.js";
 export { REQUEST_ID_EVIDENCE_ROUTE, REQUEST_ID_HEADER } from "./request-id.js";
 export { loopsContract } from "./contracts/loops.contract.js";
@@ -104,11 +109,15 @@ export * from "./history-state.js";
 export * from "./agent-catalog.js";
 export * from "./agent-run-model.js";
 export * from "./capability-env.js";
+export * from "./command-classes.js";
+export * from "./credential-material.js";
 export * from "./capability-secrets.js";
 export * from "./conversation-ids.js";
 export * from "./documents.js";
 export * from "./fast-tier.js";
 export * from "./host-protocol.js";
+export * from "./webext-protocol.js";
+export * from "./webext-links.js";
 export * from "./runner-protocol.js";
 export * from "./listener-protocol.js";
 export * from "./hostnames.js";
@@ -118,7 +127,61 @@ export * from "./prompt-complexity.js";
 export * from "./quick-model.js";
 export * from "./output-fields.js";
 export * from "./publish-drafts.js";
-export * from "./schemas.js";
+/* The wire shapes, one module per subject area, mirroring `contracts/` above: every request and response the
+ * daemon speaks is declared in exactly one of them. Inputs that carry a `{param}` in their route path (repo /
+ * id / name) merge the path param into the same flat object, oRPC fills the path placeholder from the matching
+ * key and routes the rest to the body (POST/PUT) or query (GET).
+ *
+ * `schemas/internal.ts` is deliberately absent: it holds the id and ref primitives these modules are written
+ * in, which are vocabulary rather than shapes either side of the wire sends. */
+export * from "./schemas/activity.js";
+export * from "./schemas/agent.js";
+export * from "./schemas/agents.js";
+export * from "./schemas/automations.js";
+export * from "./schemas/capabilities.js";
+export * from "./schemas/ci.js";
+export * from "./schemas/claude-gate.js";
+export * from "./schemas/codebase-health.js";
+export * from "./schemas/computers.js";
+export * from "./schemas/drafts.js";
+export * from "./schemas/environment.js";
+export * from "./schemas/exit.js";
+export * from "./schemas/extension-updates.js";
+export * from "./schemas/fast-mode.js";
+export * from "./schemas/git.js";
+export * from "./schemas/git-history.js";
+export * from "./schemas/history.js";
+export * from "./schemas/hosts.js";
+export * from "./schemas/intentic.js";
+export * from "./schemas/inventory.js";
+export * from "./schemas/issues.js";
+export * from "./schemas/logs.js";
+export * from "./schemas/loops.js";
+export * from "./schemas/maintenance.js";
+export * from "./schemas/marketplace.js";
+export * from "./schemas/panels.js";
+export * from "./schemas/personas.js";
+export * from "./schemas/plan-limits.js";
+export * from "./schemas/ports.js";
+export * from "./schemas/provider-oauth.js";
+export * from "./schemas/provider-subscriptions.js";
+export * from "./schemas/public.js";
+export * from "./schemas/push.js";
+export * from "./schemas/secrets.js";
+export * from "./schemas/sessions.js";
+export * from "./schemas/settings.js";
+export * from "./schemas/share.js";
+export * from "./schemas/shared.js";
+export * from "./schemas/system.js";
+export * from "./schemas/terminal.js";
+export * from "./schemas/usage.js";
+export * from "./schemas/vpn.js";
+export * from "./schemas/webext.js";
+export * from "./schemas/workflows.js";
+export * from "./schemas/workspace-repos.js";
+export * from "./schemas/workspace-search.js";
+export * from "./schemas/workspace-setup.js";
+export * from "./schemas/workspace-tree.js";
 export * from "./definition.js";
 export * from "./search-globs.js";
 export * from "./starter.js";
@@ -154,6 +217,7 @@ export const sandboxContract = {
     history: historyContract,
     workspace: workspaceContract,
     inventory: inventoryContract,
+    issues: issuesContract,
     logs: logsContract,
     loops: loopsContract,
     panels: panelsContract,

package/src/listener-protocol.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ActivityStatusSchema } from "./schemas.js";
+import { ActivityStatusSchema } from "./schemas/activity.js";
 
 /* The wire between the daemon and an extension's realtime-listener GATEWAY process (ext-discord, ext-slack,
  * ext-telegram, ext-whatsapp, ext-imap): the four provider-scoped routes app.ts mounts under

package/src/quick-model.ts

@@ -1,6 +1,6 @@
 import { ACCESS_COST, accessFor, modelsFor, PROVIDERS } from "./agent-catalog.js";
 import { compareCheapestFirst, familyOf, tierRankOf } from "./model-order.js";
-import type { AgentProvider } from "./schemas.js";
+import type { AgentProvider } from "./schemas/agent.js";
 
 /* THE QUICK MODEL, the cheap, fast model a small automatic job spends instead of the frontier model the chat
  * runs on. Today that is the commit message written when an agent's work lands; anything else of that shape (a

package/src/routes.test.ts

@@ -77,7 +77,9 @@ describe(`routeShapes`, () => {
     it(`changes the fingerprint when a field is added`, () => {
         const before = routeShapes(shaped(z.object({ a: z.string() })))[`vpn.list`];
         const after = routeShapes(shaped(z.object({ a: z.string(), b: z.number() })))[`vpn.list`];
-        expect(before).toBeDefined();
+        // A fingerprint is a string, and saying so is what makes the line below mean something: with `before`
+        // undefined and `after` a real shape, "they differ" is true for the wrong reason.
+        expect(before).toEqual(expect.any(String));
         expect(after).not.toBe(before);
     });
 
@@ -99,7 +101,7 @@ describe(`routeShapes`, () => {
         const one = z.object({ a: z.string().default(`x`) });
         const asOutput = routeShapes(shaped(one))[`vpn.list`];
         const asInput = routeShapes({ vpn: { list: oc.route({ method: "GET", path: "/vpn" }).input(one) } })[`vpn.list`];
-        expect(asOutput).toBeDefined();
+        expect(asOutput).toEqual(expect.any(String));
         expect(asInput).not.toBe(asOutput);
     });
 

package/src/runner-protocol.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { DefinitionActionSchema } from "./definition-action.js";
 
 /* THE RUNNER LINK'S EDGES: the handshake on /system/runners/connect, the env a runner boots with, and the
  * placement value a turn request carries. The procedures spoken over the link once it exists live in
@@ -30,6 +31,13 @@ export const RunnerHelloSchema = z.object({
     image: z.string(),
     channel: z.string().optional(),
     overlayHash: z.string().optional(),
+    /* The runner's DECLARED SHAPE, as the definition format spells it (definition.ts): a sandbox.toml whose
+     * only populated section is settings, because that is all a runner declares — capabilities and secrets
+     * never travel to one, and its repos are a mirror of the parent's git rather than clones with remotes.
+     * The parent diffs this against its own settings to itemize drift (a stale toolchain is a rebuild; a
+     * drifted setting is one applyDefinition call over this same socket), so parity stops being a bare
+     * "outdated" and becomes lines naming what differs. Absent on an image too old to derive one. */
+    definitionToml: z.string().optional(),
 });
 export type RunnerHello = z.infer<typeof RunnerHelloSchema>;
 
@@ -44,7 +52,8 @@ export const runnerEnrollUrl = (parentUrl: string): string => `${parentUrl.repla
  * parent serves from its real git dirs (<historyRoot>/gits/<encoded id>), authenticated by the runner's own
  * token as a bearer. One builder because three parties spell it: the parent's route, the runner's sync, and
  * anyone debugging with a hand-typed clone. */
-export const runnerGitUrl = (parentUrl: string, repo: string): string => `${parentUrl.replace(/\/$/, "")}/system/runners/git/${encodeURIComponent(repo)}`;
+export const runnerGitUrl = (parentUrl: string, repo: string): string =>
+    `${parentUrl.replace(/\/$/, "")}/system/runners/git/${encodeURIComponent(repo)}`;
 
 /* Where a runner's push LANDS in the parent's git dirs. Never refs/heads/agent/<id> directly: that branch is
  * checked out in the parent's mirror worktree, and git itself refuses updating a checked-out ref, which is a
@@ -52,6 +61,12 @@ export const runnerGitUrl = (parentUrl: string, repo: string): string => `${pare
  * the mirror worktree to this ref, which advances the checked-out branch through the door git sanctions. */
 export const runnerIncomingRef = (conversationId: string): string => `refs/runner-incoming/${conversationId}`;
 
+/* THE CONTAINER A RUNNER'S NAME MEANS on the machine holding it, which is how the update and rebuild flows
+ * address it. The prefix is `ic`'s own (runner.rs SLUG_PREFIX) and the two must stay identical: a mismatch
+ * does not fail loudly, it sends an update at a container that does not exist and reports "no such sandbox"
+ * about a runner sitting right there in the list. */
+export const runnerSlug = (name: string): string => `runner-${name}`;
+
 /* THE CREDENTIAL DOORS: a runner's turns spend the ORIGIN sandbox's model providers, never accounts of their
  * own. The shape is a service, not a sync: the parent resolves each turn's credential with the same code its
  * local turns use and answers with the least that travels — an access token minted for the turn, or a route.
@@ -128,10 +143,20 @@ export const RunnerFactsSchema = z.object({
 });
 export type RunnerFacts = z.infer<typeof RunnerFactsSchema>;
 
+/* WHETHER IT IS RUNNING WHAT THIS SANDBOX IS RUNNING (§7 of the design): `current` matches on image, channel
+ * and approved overlay; `outdated` differs on one of them and gets the update button; `unknown` is a runner
+ * that has never connected, or a parent that cannot name its own image (a dev daemon), where a warning would
+ * be one nobody can act on. Reported, never enforced: an outdated runner still runs turns. */
+export const RunnerParitySchema = z.enum(["current", "outdated", "unknown"]);
+export type RunnerParity = z.infer<typeof RunnerParitySchema>;
+
 // One runner as the owner's views list it: enrolled state plus whatever the hub knows right now, the
 // HostSummary shape retold for a runner (no platform/scopes, parity instead).
 export const RunnerSummarySchema = z.object({
     id: z.string(),
+    // The connected computer holding it, when this sandbox is what asked for it (the Computers view's create
+    // flow). Absent for one started by hand on a machine, which this sandbox can dispatch to but not manage.
+    host: z.string().optional(),
     online: z.boolean(),
     version: z.string().optional(),
     image: z.string().optional(),
@@ -139,6 +164,14 @@ export const RunnerSummarySchema = z.object({
     overlayHash: z.string().optional(),
     facts: RunnerFactsSchema.optional(),
     lastSeen: z.number().optional(),
+    // Computed by the daemon (runners/runner-parity.ts) rather than by each surface, so the badge on a row and
+    // the note in the placement picker cannot disagree about the same runner.
+    parity: RunnerParitySchema,
+    /* Where the runner's environment stands against this sandbox's, one line per difference (the definition
+     * surface's drift unit, computed parent-side from the hello's definitionToml plus the overlay hashes).
+     * Absent when the runner never said, empty when they agree. Lines whose subject is a Setting are fixable
+     * over the live link (the sync door); an overlay line takes a rebuild. */
+    drift: z.array(DefinitionActionSchema).optional(),
 });
 export type RunnerSummary = z.infer<typeof RunnerSummarySchema>;
 
@@ -202,8 +235,5 @@ export type RunnerTurn = z.infer<typeof RunnerTurnSchema>;
  * client sends them. `runner` implies isolation, a remote conversation is always branch-anchored, because its
  * branch is the unit that moves between machines. Absent means local, which is why this is optional
  * everywhere: the default costs nothing to anyone who never uses it. */
-export const AgentPlacementSchema = z.union([
-    z.object({ kind: z.literal("local") }),
-    z.object({ kind: z.literal("runner"), id: z.string().min(1) }),
-]);
+export const AgentPlacementSchema = z.union([z.object({ kind: z.literal("local") }), z.object({ kind: z.literal("runner"), id: z.string().min(1) })]);
 export type AgentPlacement = z.infer<typeof AgentPlacementSchema>;

package/src/runtime-state.ts

@@ -69,6 +69,22 @@ const RUNTIME_DOMAINS = [
     // is why the daemon rate-limits this domain rather than pushing every mutation (see runtime-watch.ts).
     { domain: "subagents", invalidates: [["subagents"]] },
 
+    /* THE MACHINES ON THE OTHER END OF A SOCKET, three domains that are one story: the user's computers, the
+     * browsers holding the extension, and this sandbox's runners.
+     *
+     * Announced, and about as announced as a fact can be. "Online" here is not sampled, inferred or timed out
+     * of, it IS a socket in this process: the hub accepts one, replaces one, drops one on a failed heartbeat, or
+     * cuts one on a revoke, and those four moments are the entire set of ways the answer changes. Nothing on
+     * disk moves, no pane appears, and no other feed could carry it.
+     *
+     * They land on `capabilities` because a host or webext card's state is LITERALLY the hub's answer
+     * (handlers/host.ts: `hub.online(id) ? active : pending`), which is what a person watches while they paste a
+     * pairing command into a laptop. That wait is the whole reason these are here: it was three seconds of
+     * polling per card, running only because nobody had told the browser that the daemon already knew. */
+    { domain: "hosts", invalidates: [["capabilities"], ["computers"]] },
+    { domain: "webext", invalidates: [["capabilities"]] },
+    { domain: "runners", invalidates: [["runners"]] },
+
     /* The post queue, when the DAEMON moves it rather than the owner. Approving is the owner's own mutation and
      * refetches itself, but everything after that happens while nobody is touching the page: a held post coming
      * due, a Discord send landing, a publish turn writing back what went out. Those are the moments the row on

package/src/schemas/activity.ts

@@ -0,0 +1,123 @@
+// activity: the activity audit log (historyRoot/activity.jsonl)
+import { z } from "zod";
+import { AgentOriginSchema } from "./agent.js";
+// One provider-agnostic event per agent↔provider interaction, appended by the daemon only (never the agent,
+// the log lives under historyRoot, outside /work, so the agent can't read or rewrite its own trail). Discord
+// is the first source; other cli providers reuse the same shape.
+
+export const ActivityEventSchema = z.object({
+    id: z.string().describe("The entry's own id."),
+    // Epoch ms; also the paging cursor.
+    at: z.number().describe("When it happened, in milliseconds. Also what you page by."),
+    // "discord", …; absent on provider-less system events (a cron automation.run).
+    provider: z.string().optional().describe("Which outside service, when one was involved. Absent for the sandbox's own events."),
+    // Which provider account handled the turn, the attribution key for per-account usage totals. Absent on
+    // provider-less events and turns that ran on the provider's default account.
+    account: z
+        .string()
+        .optional()
+        .describe("Which account handled it. Absent for the sandbox's own events and for work run on a provider's default."),
+    direction: z.enum(["in", "out", "system"]).describe("Whether something arrived, something went out, or the sandbox did it to itself."),
+    // in: message.received | voice_utterance.received | voice_transcript.received
+    // out: message.send | reaction.add | messages.read | api.call (unclassified provider endpoint)
+    // system: gateway.login_failed | dispatch.failed | voice.session_started | voice.session_ended | automation.run
+    //         | turn.started | turn.plan | turn.error | turn.completed (agent turn lifecycle; provider = claude/codex)
+    //         | rule.blocked_push | rule.held_work | rule.continued_turn (a rule DID something, see RuleSchema.
+    //           Only the three outcomes a person would otherwise have no explanation for: a push that did not
+    //           go, work that did not arrive, a turn that did not end. A rule that ran and passed says nothing,
+    //           because a feed that logs every green check is one the eye learns to skip.)
+    type: z
+        .string()
+        .describe(
+            "Exactly what happened: a message received or sent, a reaction, a turn starting or ending, a rule doing something. A rule that ran and passed says nothing here, because a feed of green ticks is one the eye learns to skip.",
+        ),
+    channelId: z.string().optional().describe("Which channel or thread it happened in."),
+    // Inbound author display name.
+    author: z.string().optional().describe("Who sent it, for something that arrived."),
+    // Full message text (inbound) or sent payload content (outbound).
+    content: z.string().optional().describe("The message, in full, whichever direction it went."),
+    // Outbound HTTP method + endpoint path (tokens ride headers, never URLs).
+    method: z.string().optional().describe("The verb of an outgoing call."),
+    endpoint: z.string().optional().describe("The address of an outgoing call. Credentials travel in headers, so they are never here."),
+    // The agent turn that made/handled it, the join key between an inbound wake and its outbound calls.
+    sessionId: z.string().optional().describe("The provider session behind it."),
+    /* ONE TURN'S EVENTS, TIED TOGETHER. A turn writes four lifecycle events plus one per outbound provider call,
+     * and read as five rows they say one thing five times, so the feed groups on this instead. It cannot be
+     * sessionId: the runtime does not mint one until the stream's first frame, which is AFTER turn.started, so
+     * the very event carrying the prompt is the one that could never be joined. Minted by the turn itself. */
+    turnId: z
+        .string()
+        .optional()
+        .describe(
+            "Ties one turn's entries together. A turn writes several, and read as separate rows they say one thing several times, so a feed groups on this.",
+        ),
+    // The stable conversation the turn belongs to. Outlives sessionId, which a provider/account/harness switch
+    // retires mid-conversation, so this, not sessionId, is what "the same agent" means across a feed.
+    conversationId: z
+        .string()
+        .optional()
+        .describe(
+            "Which conversation. This, rather than the provider session, is what the same agent means across a feed, because a session is retired whenever the model changes.",
+        ),
+    // The conversation's display title as it stood when the event was written. Denormalised on purpose: the
+    // registry entry it came from is prunable and renameable, and an audit row must still read as words years
+    // later. Absent on the first event of a fresh conversation, the auto-namer has not run yet.
+    title: z
+        .string()
+        .optional()
+        .describe(
+            "What that conversation was called at the time. Copied in rather than looked up, because an audit entry must still read as words years later, after the conversation has been renamed or pruned.",
+        ),
+    // What woke the conversation from outside, when something did (see AgentOriginSchema), the feed's "who
+    // called me" attribution, and how a turn is filed under Discord rather than under the runtime that served it.
+    origin: AgentOriginSchema.optional().describe(
+        "What woke the conversation from outside, when something did. It is how a turn gets filed under the chat service that caused it rather than under the model that served it.",
+    ),
+    automationIds: z.array(z.string()).optional().describe("Which automations were involved."),
+    outcome: z.enum(["ok", "error"]).optional().describe("How it ended."),
+    error: z.string().optional().describe("What went wrong, when something did."),
+    // Source-specific detail: guildId, attachments, transcript path, participants…
+    extra: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe("Whatever else the source had to say: attachments, participants, a recording's path. Shape varies by source."),
+});
+export type ActivityEvent = z.infer<typeof ActivityEventSchema>;
+export const ActivityQuerySchema = z.object({
+    provider: z.string().optional().describe("Narrow it to one outside service."),
+    limit: z.coerce.number().min(1).max(500).default(100).describe("How many entries to return."),
+    // `at` cursor, exclusive, newest-first paging.
+    before: z.coerce.number().optional().describe("Only entries older than this timestamp, so paging walks backwards through the feed."),
+});
+export type ActivityQuery = z.infer<typeof ActivityQuerySchema>;
+export const ActivityListSchema = z.object({ events: z.array(ActivityEventSchema).describe("The audit entries, newest first.") });
+// Live connection health, probed per provider capability (not stored): gateway state from the client pool
+// (idle = the gateway is up but has no enabled listener automation to connect for, distinct from a
+// connection that should be up but isn't; pairing = the socket is up but the credential is a ceremony nobody
+// has finished, which no amount of waiting fixes), lastError from the newest system-error event in the log.
+export const ActivityConnectionSchema = z.object({
+    capabilityId: z.string().describe("Which connection."),
+    provider: z.string().describe("Which service it is."),
+    gateway: z
+        .enum(["ready", "connecting", "pairing", "disconnected", "idle"])
+        .describe(
+            "Idle means it is up but has nothing to listen for, which is different from a connection that should be up and is not. Pairing means somebody started a sign-in and never finished it, which no amount of waiting will fix.",
+        ),
+    lastError: z.string().optional().describe("The most recent thing that went wrong on it."),
+});
+export const ActivityStatusSchema = z.object({
+    connections: z
+        .array(ActivityConnectionSchema)
+        .describe("Each source feeding the record, and whether it is working. Probed now rather than remembered."),
+    // The daemon's live voice session, when one is up.
+    voice: z
+        .object({
+            channelId: z.string().describe("Which channel."),
+            channelName: z.string().describe("What it is called."),
+            startedAt: z.number().describe("When it joined, in milliseconds."),
+            participants: z.array(z.string()).describe("Who else is in it."),
+        })
+        .optional()
+        .describe("A voice call the sandbox is currently in, when it is in one."),
+});
+export type ActivityStatus = z.infer<typeof ActivityStatusSchema>;