@fungi.computer/oyster 0.3.2 → 0.4.1

package/dist/standalone/app-set.d.ts

@@ -60,6 +60,13 @@ export type InstalledStarterApp = Readonly<{
     release: Schema.Json;
     timings: StarterAppTimings;
 }>;
+export type StarterAppSetResult = Readonly<{
+    installed: readonly InstalledStarterApp[];
+    failed: readonly Readonly<{
+        installationId: string;
+        reason: string;
+    }>[];
+}>;
 /**
  * Builds the installer runs at once by default. A build's compiler may take a
  * 4 GB heap, so two fit the platform's 12 GiB Computer (standard-4) with room
@@ -91,4 +98,4 @@ export declare function installStandaloneAppSet(options: Readonly<{
     /** The idle wait between build status reads; the real timer by default. */
     idle?: (ms: number, signal: AbortSignal) => Promise<void>;
     waitMs?: number;
-}>): Promise<readonly InstalledStarterApp[]>;
+}>): Promise<StarterAppSetResult>;

package/dist/standalone/app-set.js

@@ -72,7 +72,13 @@ const publishedSchema = Schema.Struct({
 });
 const buildSchema = Schema.Struct({
     jobId: Schema.String,
-    status: Schema.Literals(["running", "succeeded", "failed", "revoked"]),
+    status: Schema.Literals([
+        "running",
+        "succeeded",
+        "failed",
+        "interrupted",
+        "revoked",
+    ]),
     detail: Schema.NullOr(Schema.String),
     /** Installed exactly as the host encoded it. */
     release: Schema.NullOr(Schema.Json),
@@ -271,10 +277,15 @@ export async function installStandaloneAppSet(options) {
         }
     };
     const installed = new Map();
-    /** Set by the first failure, so no further seed or build starts. */
-    const stop = { requested: false };
-    /** Every failure, in the order it happened; the first is the one thrown. */
-    const failures = [];
+    const failures = new Map();
+    const fail = (app, cause) => {
+        const reason = cause instanceof Error ? cause.message : String(cause);
+        failures.set(app.installationId, reason);
+        options.report(`Failed ${app.installationId}: ${reason}`);
+    };
+    const reportFailure = ({ app, cause, }) => {
+        fail(app, cause);
+    };
     const seededQueue = [];
     const waiting = [];
     const seeding = { finished: false };
@@ -318,21 +329,19 @@ export async function installStandaloneAppSet(options) {
     const seedAll = async () => {
         try {
             for (const app of standaloneAppSet) {
-                if (stop.requested)
-                    break;
-                const seeded = await seedApp(app);
-                const waiter = waiting.shift();
-                if (waiter === undefined)
-                    seededQueue.push(seeded);
-                else
-                    waiter(seeded);
+                try {
+                    const seeded = await seedApp(app);
+                    const waiter = waiting.shift();
+                    if (waiter === undefined)
+                        seededQueue.push(seeded);
+                    else
+                        waiter(seeded);
+                }
+                catch (cause) {
+                    reportFailure({ app, cause });
+                }
             }
         }
-        catch (cause) {
-            stop.requested = true;
-            failures.push(cause);
-            throw cause;
-        }
         finally {
             seeding.finished = true;
             for (const waiter of waiting.splice(0))
@@ -341,7 +350,7 @@ export async function installStandaloneAppSet(options) {
     };
     // `concurrency` builds at once, each installing as its build succeeds.
     const slot = async () => {
-        for (let next = await takeSeeded(); next !== undefined && !stop.requested; next = await takeSeeded()) {
+        for (let next = await takeSeeded(); next !== undefined; next = await takeSeeded()) {
             const name = next.app.installationId;
             try {
                 const buildStarted = performance.now();
@@ -416,22 +425,28 @@ export async function installStandaloneAppSet(options) {
                 });
             }
             catch (cause) {
-                stop.requested = true;
-                failures.push(cause);
-                throw cause;
+                reportFailure({ app: next.app, cause });
             }
         }
     };
-    // Wait for every seed and build to settle before reporting: nothing of this
-    // call may still run, or install, after it rejects.
-    await Promise.allSettled([
+    // Wait for every seed and build to settle before returning the full outcome.
+    const settled = await Promise.allSettled([
         seedAll(),
         ...Array.from({ length: concurrency }, slot),
     ]);
-    if (failures.length > 0)
-        throw failures[0];
-    return standaloneAppSet.flatMap((app) => {
-        const result = installed.get(app.installationId);
-        return result === undefined ? [] : [result];
-    });
+    for (const outcome of settled)
+        if (outcome.status === "rejected")
+            throw outcome.reason;
+    return {
+        installed: standaloneAppSet.flatMap((app) => {
+            const result = installed.get(app.installationId);
+            return result === undefined ? [] : [result];
+        }),
+        failed: standaloneAppSet.flatMap((app) => {
+            const reason = failures.get(app.installationId);
+            return reason === undefined
+                ? []
+                : [{ installationId: app.installationId, reason }];
+        }),
+    };
 }

package/dist/standalone/computer-control.d.ts

@@ -0,0 +1,4 @@
+import type { ComputerControlPort } from "../mcp.js";
+import type { StandaloneRegistryRpc } from "./registry.js";
+/** MCP control speaks to the same owner-admitted durable fleet as HTTP. */
+export declare function standaloneComputerControl(registry: Pick<StandaloneRegistryRpc, "computerFleet">, memberId: string): ComputerControlPort;

package/dist/standalone/computer-control.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { computerStateSchema, } from "@fungi.computer/computer/fleet";
+import { teamComputerDirectorySchema } from "@fungi.computer/nacre/workbench";
+const inventoryComputer = z.strictObject({
+    computerId: z.string(),
+    name: z.string(),
+    createdAt: z.number(),
+    updatedAt: z.number(),
+});
+const inventoryPage = z.strictObject({
+    computers: z.array(inventoryComputer),
+    nextOffset: z.number().int().nonnegative().nullable(),
+});
+const inventoryError = z.strictObject({
+    error: z.string(),
+});
+/** MCP control speaks to the same owner-admitted durable fleet as HTTP. */
+export function standaloneComputerControl(registry, memberId) {
+    const fleet = (request) => registry.computerFleet(memberId, request);
+    const available = (result) => {
+        if (result === null || inventoryError.safeParse(result).success)
+            throw new Error("Computer fleet refused the request");
+        return result;
+    };
+    return {
+        list: async (page) => teamComputerDirectorySchema.parse(inventoryPage.parse(available(await fleet({ operation: "list", page })))),
+        state: async (computerId) => computerStateSchema.parse(available(await fleet({ operation: "state", computerId }))),
+        start: async (computerId) => computerStateSchema.parse(available(await fleet({ operation: "start", computerId }))),
+        create: async (input) => {
+            let result;
+            try {
+                result = await fleet({ operation: "create", request: input });
+            }
+            catch {
+                // Creation may have persisted before the RPC failed. Surface its
+                // identity so the caller can retry, never silently mint another one.
+                return { kind: "uncertain" };
+            }
+            if (result === null)
+                return { kind: "denied" };
+            const error = inventoryError.safeParse(result);
+            if (error.success) {
+                switch (error.data.error) {
+                    case "owner_required":
+                        return { kind: "denied" };
+                    case "name_taken":
+                    case "request_conflict":
+                        return { kind: "conflict" };
+                    case "partial_init":
+                        return { kind: "uncertain" };
+                    default:
+                        return { kind: "invalid" };
+                }
+            }
+            const computer = inventoryComputer.parse(result);
+            return {
+                kind: "created",
+                computer: { computerId: computer.computerId, name: computer.name },
+            };
+        },
+    };
+}

package/dist/standalone/computer-fleet.d.ts

@@ -23,6 +23,7 @@ export declare const standaloneFleetRequestSchema: z.ZodDiscriminatedUnion<[z.Zo
         resolve: "resolve";
         select: "select";
         start: "start";
+        state: "state";
     }>;
     computerId: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{

package/dist/standalone/computer-fleet.js

@@ -15,7 +15,7 @@ export const standaloneFleetRequestSchema = z.discriminatedUnion("operation", [
         page: computerPageSchema,
     }),
     z.strictObject({
-        operation: z.enum(["read", "resolve", "start", "select"]),
+        operation: z.enum(["read", "resolve", "state", "start", "select"]),
         computerId: fleetComputerId,
     }),
     z.strictObject({

package/dist/standalone/computer.d.ts

@@ -4,7 +4,8 @@ import { type PreviewSelector } from "./preview.js";
 import { type StandaloneTenancyEnv } from "./tenancy.js";
 import * as z from "zod";
 import { computerProcessSchema, computerToolResultSchema, readOutputSchema } from "@fungi.computer/computer-contract";
-import { ComputerDO as NativeComputerDO, type AttachedBackend, type ComputerEnv } from "@fungi.computer/computer";
+import { ComputerDO as NativeComputerDO, type AttachedBackend, type ComputerEnv, type ComputerFilesRpc } from "@fungi.computer/computer";
+import { patchInputSchema, patchOutputSchema } from "@fungi.computer/knapsack/files-patch";
 import { listOutputSchema, writeOutputSchema, mkdirOutputSchema, computerPortsOutputSchema, computerPortOutputSchema, computerPortRemovalOutputSchema, processListOutputSchema, processKillOutputSchema, computerOperationResultSchema, type ComputerExecutionHostHooks, type ComputerValue } from "@fungi.computer/computer-contract";
 import { type WorkflowGitCredential, type WorkflowGitPassGrant } from "@fungi.computer/braid/runtime";
 import { type ComputerAction, type ComputerGrant } from "@fungi.computer/computer/fleet";
@@ -66,8 +67,13 @@ export type StandaloneWorkflowGitIssuer = Readonly<{
 export type ComputerFetch = {
     fetch(request: Request): Promise<Response>;
 };
+/** The additional native doors an attached Agent may use on this Computer. */
+export type StandaloneAgentComputerRpc = ComputerFilesRpc & Readonly<{
+    tool(authority: ComputerGrant, capabilityId: string, input: ComputerValue): Promise<StandaloneComputerResult>;
+    filePatch(authority: ComputerGrant, input: z.output<typeof patchInputSchema>): Promise<z.output<typeof patchOutputSchema>>;
+}>;
 /** Durable workspace and existing backings, with fleet checks at native acceptance. */
-export declare class ComputerDO extends NativeComputerDO implements ComputerFetch {
+export declare class ComputerDO extends NativeComputerDO implements ComputerFetch, StandaloneAgentComputerRpc {
     #private;
     private readonly previewBindings;
     constructor(state: DurableObjectState, previewBindings: StandaloneComputerOwnerEnv);
@@ -77,6 +83,17 @@ export declare class ComputerDO extends NativeComputerDO implements ComputerFetc
     startHostedComputer(authority: ComputerGrant): Promise<{
         state: "running";
     }>;
+    /** Observe an admitted fleet Computer without starting its backend. */
+    readHostedComputerState(authority: ComputerGrant): Promise<{
+        state: "queued";
+        position: number;
+    } | {
+        state: "running" | "starting";
+        position?: never;
+    } | {
+        state: "running" | "sleeping";
+        position?: never;
+    }>;
     /** A read-only preflight over the maintained hosted-route selector. */
     buildBackend(): OysterBuildBackend;
     /**
@@ -120,6 +137,8 @@ export declare class ComputerDO extends NativeComputerDO implements ComputerFetc
     /** Binary files share the same native filesystem as commands and PTYs. */
     fileRead(authority: ComputerGrant, path: string): Promise<Uint8Array | null>;
     fileWrite(authority: ComputerGrant, path: string, bytes: Uint8Array): Promise<void>;
+    /** Patch is handled by the Computer's pinned native engine, not by the Agent. */
+    filePatch(authority: ComputerGrant, input: z.output<typeof patchInputSchema>): Promise<z.output<typeof patchOutputSchema>>;
     fileReplace(authority: ComputerGrant, path: string, expectedContent: string, content: string): Promise<{
         path: string;
         bytes: number;

package/dist/standalone/computer.js

@@ -11,6 +11,7 @@ import { Base64 } from "effect/encoding";
 import * as z from "zod";
 import { ComputerPortConflictError, computerByteReadReplySchema, computerProcessSchema, installationProcessScope, processStartInputSchema, processStartToolInputSchema, computerCapabilities, computerToolResultSchema, readOutputSchema, } from "@fungi.computer/computer-contract";
 import { ComputerDO as NativeComputerDO, ComputerOperationConflictError, } from "@fungi.computer/computer";
+import { patchInputSchema, patchOutputSchema, } from "@fungi.computer/knapsack/files-patch";
 import { ComputerFileConflict, computerExecutionRequestSchema, computerValueSchema, computerPortInputSchema, listInputSchema, listOutputSchema, readBytesInputSchema, writeInputSchema, replaceInputSchema, writeOutputSchema, mkdirOutputSchema, computerPortsOutputSchema, computerPortOutputSchema, computerPortRemovalOutputSchema, processListOutputSchema, processKillOutputSchema, computerOperationResultSchema, mintComputerRequestId, processIdInputSchema, } from "@fungi.computer/computer-contract";
 import { workflowGitExecutionEnvironment, workflowGitPassGrantSchema, } from "@fungi.computer/braid/runtime";
 import { checkComputerGrant, computerActionSchema, computerGrantSchema, createFleetBacking, FleetGrantRefused, FleetLifecycle, } from "@fungi.computer/computer/fleet";
@@ -173,6 +174,11 @@ export class ComputerDO extends NativeComputerDO {
             await run();
         });
     }
+    /** Observe an admitted fleet Computer without starting its backend. */
+    readHostedComputerState(authority) {
+        this.#accept(authority, "start");
+        return this.#fleetLifecycle().readComputerState();
+    }
     #previewGrant(ownerId) {
         return {
             computerId: this.#id(),
@@ -455,6 +461,12 @@ export class ComputerDO extends NativeComputerDO {
             this.#accept(authority, "files.writeBytes");
         });
     }
+    /** Patch is handled by the Computer's pinned native engine, not by the Agent. */
+    async filePatch(authority, input) {
+        return this.applyPatchAfterAcceptance(input, () => {
+            this.#accept(authority, "files.edit");
+        });
+    }
     async fileReplace(authority, path, expectedContent, content) {
         try {
             const result = await this.replaceFileIfUnchangedAfterAcceptance({ path, expectedContent, content }, () => {

package/dist/standalone/install-apps-bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/standalone/install-apps-bin.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runInstallAppsCli } from "./install-apps-cli.js";
+await runInstallAppsCli();

package/dist/standalone/install-apps-cli.d.ts

@@ -1,2 +1,4 @@
 #!/usr/bin/env node
-export {};
+import { installStandaloneAppSet } from "./app-set.js";
+export declare function installApps(args: readonly string[], install?: typeof installStandaloneAppSet): Promise<void>;
+export declare function runInstallAppsCli(args?: readonly string[]): Promise<void>;

package/dist/standalone/install-apps-cli.js

@@ -76,7 +76,7 @@ function timingTable(results) {
     ];
     return [header, ...rows].map((row) => row.join("\t")).join("\n");
 }
-async function installApps(args) {
+export async function installApps(args, install = installStandaloneAppSet) {
     const { values } = parseArgs({
         args: [...args],
         options: {
@@ -121,7 +121,7 @@ async function installApps(args) {
             source = { kind: "checkout", directory, revision: `git:${revision}` };
         }
         const started = performance.now();
-        const results = await installStandaloneAppSet({
+        const { installed, failed } = await install({
             source,
             url,
             key,
@@ -131,33 +131,43 @@ async function installApps(args) {
             },
         });
         const elapsed = performance.now() - started;
-        process.stdout.write(`\n${timingTable(results)}\n`);
-        process.stdout.write(`\nInstalled ${String(results.length)} Apps in ${seconds(elapsed)}. Open ${url}/ to use Tourtois and the installed Apps.\n`);
+        process.stdout.write(`\n${timingTable(installed)}\n`);
+        process.stdout.write("\nApp\tResult\n");
+        for (const app of installed)
+            process.stdout.write(`${app.installationId}\tinstalled\n`);
+        for (const app of failed)
+            process.stdout.write(`${app.installationId}\tfailed: ${app.reason}\n`);
+        process.stdout.write(`\nInstalled ${String(installed.length)} Apps; failed ${String(failed.length)} in ${seconds(elapsed)}.${installed.length > 0 ? ` Open ${url}/ to use the installed Apps.` : ""}\n`);
         if (values.timings !== undefined)
             await writeFile(values.timings, JSON.stringify({
                 concurrency,
                 elapsedMs: elapsed,
-                apps: results.map(({ installationId, jobId, timings }) => ({
+                apps: installed.map(({ installationId, jobId, timings }) => ({
                     installationId,
                     jobId,
                     timings,
                 })),
+                failed,
             }, null, 2) + "\n");
+        if (failed.length > 0)
+            process.exitCode = 1;
     }
     finally {
         await rm(scratch, { recursive: true, force: true });
     }
 }
-const [command, ...rest] = process.argv.slice(2);
-if (command === "--help" || command === "-h") {
-    process.stdout.write(usage + "\n" + installReleaseUsage + "\n");
-}
-else if (command !== "install-apps" && command !== "install") {
-    process.stderr.write(`${usage}\n`);
-    process.exitCode = 2;
+export async function runInstallAppsCli(args = process.argv.slice(2)) {
+    const [command, ...rest] = args;
+    if (command === "--help" || command === "-h") {
+        process.stdout.write(usage + "\n" + installReleaseUsage + "\n");
+    }
+    else if (command !== "install-apps" && command !== "install") {
+        process.stderr.write(`${usage}\n`);
+        process.exitCode = 2;
+    }
+    else
+        await (command === "install" ? installReleaseCommand(rest) : installApps(rest)).catch((cause) => {
+            process.stderr.write(`${cause instanceof Error ? cause.message : String(cause)}\n`);
+            process.exitCode = 1;
+        });
 }
-else
-    await (command === "install" ? installReleaseCommand(rest) : installApps(rest)).catch((cause) => {
-        process.stderr.write(`${cause instanceof Error ? cause.message : String(cause)}\n`);
-        process.exitCode = 1;
-    });

package/dist/standalone/machine-link.d.ts

@@ -265,6 +265,7 @@ export declare function standaloneMachineLinkRoutes(env: StandaloneMachineLinkEn
 /** One device's link; directory, credentials and owner state remain elsewhere. */
 export declare class MachineLinkDO extends DurableObject<StandaloneMachineLinkEnv> {
     private readonly link;
+    alarm(): Promise<void>;
     fetch(request: Request): Promise<Response>;
     deliver(id: MachineLinkIdentity, caller: MachineLinkCaller, agentId: string, envelope: PostEnvelope): Promise<PostDeliveryResult>;
     operation(id: MachineLinkIdentity, caller: MachineLinkCaller, agentId: string, operation: MachineAgentOperation): Promise<import("effect/Schema").Json>;
@@ -276,6 +277,15 @@ export declare class MachineLinkDO extends DurableObject<StandaloneMachineLinkEn
     readErasure(): Promise<{
         erased: boolean;
     }>;
+    deadLetters(id: MachineLinkIdentity, afterKey?: string): Promise<Readonly<{
+        letters: readonly Readonly<{
+            key: string;
+            reason: "refused" | "exhausted" | "expired";
+            envelope: PostEnvelope;
+            attempts: number;
+        }>[];
+        nextCursor: string | undefined;
+    }>>;
     webSocketMessage(socket: WebSocket, message: string | ArrayBuffer): Promise<void>;
     webSocketClose(socket: WebSocket, code: number, reason: string): void;
     webSocketError(socket: WebSocket): void;

package/dist/standalone/machine-link.js

@@ -176,6 +176,9 @@ export class MachineLinkDO extends DurableObject {
             console.error(operation, cause);
         },
     });
+    alarm() {
+        return this.link.alarm();
+    }
     fetch(request) {
         return this.link.fetch(request);
     }
@@ -197,6 +200,9 @@ export class MachineLinkDO extends DurableObject {
     readErasure() {
         return this.link.readErasure();
     }
+    deadLetters(id, afterKey) {
+        return this.link.deadLetters(id, afterKey);
+    }
     webSocketMessage(socket, message) {
         return this.link.webSocketMessage(socket, message);
     }

package/dist/standalone/registry.d.ts

@@ -61,6 +61,15 @@ export declare abstract class StandaloneRegistry extends OysterRegistry implemen
         }>[];
         readonly nextOffset: number | null;
     } | ({
+        state: "queued";
+        position: number;
+    } & Disposable) | ({
+        state: "running" | "starting";
+        position?: never | undefined;
+    } & Disposable) | ({
+        state: "running" | "sleeping";
+        position?: never | undefined;
+    } & Disposable) | ({
         state: "running";
     } & Disposable) | {
         error: string;
@@ -178,7 +187,7 @@ export declare abstract class StandaloneRegistry extends OysterRegistry implemen
         appId: string;
         releaseId: string;
         sourceRevision: string;
-        status: "running" | "succeeded" | "failed" | "revoked";
+        status: "running" | "succeeded" | "failed" | "interrupted" | "revoked";
         detail: string | null;
         release: Release | null;
         installation: import("../app-builds.js").OysterBuildInstallation | null;

package/dist/standalone/registry.js

@@ -129,6 +129,15 @@ export class StandaloneRegistry extends OysterRegistry {
                 await this.#fleetStorage.put("selected-computer", input.computerId);
                 return computer;
             }
+            case "state":
+                if (this.#computers.read(input.computerId) === null)
+                    return null;
+                return this.#env.COMPUTER.getByName(input.computerId).readHostedComputerState({
+                    computerId: input.computerId,
+                    actions: new Set(["start"]),
+                    expiresAt: Date.now() + 60_000,
+                    provenance: { actor: memberId },
+                });
             case "start":
                 if (this.#computers.read(input.computerId) === null)
                     return null;

package/dist/standalone/worker.js

@@ -5,6 +5,8 @@
  */
 import { createOysterGitWorker, createOysterGitMcpOwner, oysterGitRoot, } from "../workers-git.js";
 import { defaultTenant, tenantScope } from "../tenant.js";
+import { oysterPrincipalIsOwner } from "../host.js";
+import { standaloneComputerControl } from "./computer-control.js";
 import { onBoxVmIngress } from "@fungi.computer/computer";
 import { WorkerEntrypoint } from "cloudflare:workers";
 import { installationWorkerEntrypoint } from "../installation-execution.js";
@@ -28,6 +30,8 @@ import { Hono } from "hono";
 import { HTTPException } from "hono/http-exception";
 import { standaloneBuildRoutes } from "./builds.js";
 import { standaloneComputerFleetRoutes, standaloneComputerSelection, } from "./computer-fleet.js";
+import { standaloneAgentComputerRoutes } from "./agent-computers.js";
+import { agentDirectoryForScope } from "./agent-directory.js";
 import { serveOysterComputerEgress, } from "./computer-egress.js";
 import { appSourceOwnerRoutes, } from "./app-source.js";
 export { StandaloneGraphWorkflow } from "./workflows.js";
@@ -65,6 +69,9 @@ const standaloneRoot = (selectComputer) => {
         homeInstallationId: (env) => env.OYSTER_HOME_INSTALLATION,
         agents: standaloneAgents,
         workflows: standaloneWorkflowControl,
+        computerControl: (env, scope) => (principal) => oysterPrincipalIsOwner(principal)
+            ? standaloneComputerControl(tenantRegistry(env, scope), principal.actor.memberId)
+            : null,
         workspace: async (env, keysLive, scope, request) => standaloneWorkspace(env, keysLive, await selectComputer(tenantRegistry(env, scope), request)),
         capabilities: (env, workspace, keysLive) => [
             ...standaloneComputerCapabilities(env, workspace, keysLive),
@@ -97,6 +104,11 @@ const standaloneRoot = (selectComputer) => {
         ownerRoutes: (env, scope) => appSourceOwnerRoutes(env, scope)
             .route("/", standaloneBuildRoutes(() => tenantRegistry(env, scope)))
             .route("/", standaloneComputerFleetRoutes(() => tenantRegistry(env, scope)))
+            .route("/", standaloneAgentComputerRoutes({
+            attach: (principal, command) => agentDirectoryForScope(env, scope).attachComputer(command, principal, scope.tenantId),
+            detach: (principal, command) => agentDirectoryForScope(env, scope).detachComputer(command, principal, scope.tenantId),
+            read: (principal, agentId) => agentDirectoryForScope(env, scope).readAgentComputers(agentId, principal, scope.tenantId),
+        }))
             .route("/", standaloneWorkflowWebhookControls(env, () => root.hostFor(env, scope))),
     });
     return root;

package/dist/standalone/workflow-binding.d.ts

@@ -72,10 +72,10 @@ export declare const workflowFrameMethods: {
                 readonly input: {
                     readonly [x: string]: S.Json;
                 };
+                readonly requestId: string;
                 readonly bindings: Record<string, string | {
                     kind: "team-source";
                 }>;
-                readonly requestId: string;
                 readonly definition: unknown;
                 readonly delivery?: {
                     readonly agentId: string;
@@ -86,10 +86,10 @@ export declare const workflowFrameMethods: {
                 readonly input: {
                     readonly [x: string]: S.Json;
                 };
+                readonly requestId: string;
                 readonly bindings: Record<string, string | {
                     kind: "team-source";
                 }>;
-                readonly requestId: string;
                 readonly definition: S.Json;
                 readonly published: {
                     workflowId: string;