@coreplane/switchboard 1.213.0 → 1.214.0

package/dist/assets/src/core/runRecord.ts

@@ -145,8 +145,18 @@ export interface RunRecord {
    *  item 48), stored at the claim so a retried spawn finds its run. Present
    *  exactly when `parentInstanceId` is — both or neither, never one alone. */
   idempotencyKey?: string;
+  /** Where the run's conversation started (item 52): `channel` — its own
+   *  thread's history, as for every run a person, a schedule or a coordinator
+   *  started — or `parent` — a spawned child seeded from its parent's text
+   *  turns at the spawn (`DispatchOptions.seed`). Absent on records written
+   *  before it existed. */
+  seed?: RunSeed;
 }
 
+/** The two places a run's conversation can start (item 52). */
+export const RUN_SEEDS = ["channel", "parent"] as const;
+export type RunSeed = (typeof RUN_SEEDS)[number];
+
 /** The profile as the record stores it: the run's effective profile plus the preset it came from. */
 export type RunProfileRecord = RunProfile & { preset: string };
 
@@ -515,6 +525,8 @@ export function isRunRecord(v: unknown): v is RunRecord {
   // A parent is named by a run id (item 46): the same shape as the record's own.
   if (r.parentRunId !== undefined && (typeof r.parentRunId !== "string" || !RUN_ID_PATTERN.test(r.parentRunId)))
     return false;
+  // Where the conversation started (item 52): one of the two words, or absent.
+  if (r.seed !== undefined && !RUN_SEEDS.includes(r.seed as RunSeed)) return false;
   // A coordinator's child (item 48): the instance id in the platform's alphabet
   // and the key `<instance>:<step>` — both or neither; one alone is no tag.
   if ((r.parentInstanceId === undefined) !== (r.idempotencyKey === undefined)) return false;

package/dist/assets/src/core/trace/workerTrace.ts

@@ -52,6 +52,8 @@ export function shimRoute(pathname: string): string | undefined {
   if (pathname === "/costs" || pathname.startsWith("/costs/")) return "costs";
   if (pathname.startsWith("/api/")) return "api";
   if (pathname.startsWith("/admin/")) return "admin";
+  // The artifact copy (deploy/cloudflare/artifactsCopy.ts): the shim's own route, a 1 GB stream.
+  if (pathname === "/artifacts/copy") return "artifacts";
   // The model proxy's two routes (docs/reference/specs/model-proxy.md): a bounded
   // request per model call, forwarded to the container like everything else.
   if (pathname === "/v1/messages" || pathname === "/v1/chat/completions") return "model-proxy";

package/dist/assets/src/deploy/profile.ts

@@ -89,6 +89,17 @@ export const profileSchema = z.object({
   /** The Cloudflare Access application in front of the bot's dashboards, when
    *  there is one: the team domain the JWT is issued by and the app's AUD. */
   access: z.object({ teamDomain: hostname, aud: z.string().regex(/^[0-9a-f]{64}$/) }).optional(),
+  /** The artifact store's bucket (docs/reference/specs/execution.md item 20), when the installation
+   *  has one: the bot Worker's template binds it as `ARTIFACTS` and `deploy` creates it before the
+   *  upload. The bot's runtime config (`artifacts.r2.bucket`) must name the same bucket — the two
+   *  are held equal by `artifacts check`, not by the profile. R2's own bucket-name rules. */
+  artifacts: z
+    .object({
+      bucket: z
+        .string()
+        .regex(/^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/, "an R2 bucket name: 3–63 lowercase letters, digits and hyphens"),
+    })
+    .optional(),
 });
 
 export type DeploymentProfile = z.infer<typeof profileSchema>;

package/dist/assets/src/execution/residentText.ts

@@ -19,6 +19,13 @@ import type { ResidentLifecycleState } from "./residentState.js";
  *  for the runtime-replaced guidance (~120); short enough for a card note. */
 export const RESIDENT_TEXT_CAP = 300;
 
+/** Cap for a resident `error`. A refusal is a whole reply, not a card note: the
+ *  onboard not-in-installation 403 (item 35) carries two causes, the admin's
+ *  path to the fix and GitHub's own 422 body — ~600 chars, and every word past
+ *  the first 300 is the one the admin acts on. Still a bound, so a hostile body
+ *  cannot make a reply unbounded; Slack's 3000-char section stays far away. */
+export const RESIDENT_ERROR_CAP = 1000;
+
 /** Strip terminal control sequences, redact credential shapes, cap. The identity
  *  on the discriminator literals the bot compares (`runtime-replaced`,
  *  `op-refused…`, `disk-pressure:`), pinned by test. */
@@ -26,6 +33,11 @@ export function residentText(text: string): string {
   return redactAndCap(stripAnsi(text), RESIDENT_TEXT_CAP);
 }
 
+/** The same strip and redact, at the reply-sized cap — for `error` only. */
+export function residentErrorText(text: string): string {
+  return redactAndCap(stripAnsi(text), RESIDENT_ERROR_CAP);
+}
+
 const SANITIZED_FIELDS = ["error", "reason", "summary"] as const;
 
 /** How deep the sanitizer descends. The deepest resident shape today is
@@ -36,7 +48,8 @@ const SANITIZE_DEPTH = 4;
 /** A parsed resident body with its free-text fields made safe, at every level:
  *  `/residents` nests each resident's `state`/`reason` (or an `error`) under
  *  `residents[].live`, and `repo list` renders those. In each plain object only
- *  `error`, `reason` and `summary` are touched (when strings); `stderr` is
+ *  `error`, `reason` and `summary` are touched (when strings) — `error` at the
+ *  reply-sized cap, the other two at the card-sized one; `stderr` is
  *  rewritten only when it mirrors `error` (the thread routes' failure shape
  *  copies the error into stderr). Every other field — `needs`, `state`,
  *  `stdout`, `status`, bindings, numbers — passes through untouched. Arrays are
@@ -53,7 +66,9 @@ function walk(value: unknown, depth: number): unknown {
   for (const [key, v] of Object.entries(src)) {
     out[key] =
       (SANITIZED_FIELDS as readonly string[]).includes(key) && typeof v === "string"
-        ? residentText(v)
+        ? key === "error"
+          ? residentErrorText(v)
+          : residentText(v)
         : walk(v, depth - 1);
   }
   if (typeof src.stderr === "string" && src.stderr === src.error && typeof out.error === "string") {

package/dist/assets/src/providers/types.ts

@@ -88,6 +88,12 @@ export interface CompletionRequest {
   system?: string;
   messages: ChatMessage[];
   tools?: ToolDef[];
+  /** Force one of `tools`: the model must answer by calling the named tool,
+   *  so the call's input IS the answer and prose cannot occur (the request
+   *  router's shape, routing-and-config item 21). Anthropic: `tool_choice:
+   *  {type: "tool", name}`; Chat Completions: `tool_choice: {type: "function",
+   *  function: {name}}`. Absent → the model chooses. */
+  toolChoice?: { type: "tool"; name: string };
   maxTokens: number;
   /** model effort hint; providers apply it only where the model supports it */
   effort?: Effort;