@nylorun/harness 0.12.0-beta → 0.13.0-beta

package/dist/types/shared.d.ts

@@ -1,6 +1,3 @@
-import type { ContextSnapshot, ModelCandidate, ModelCall, ModelConfigurationSnapshot } from "./model.js";
-import type { InputEvent, TranscriptEntry } from "./session.js";
-import type { RequiredInteraction, ToolResult } from "./tool.js";
 export type JsonPrimitive = string | number | boolean | null;
 export type JsonValue = JsonPrimitive | JsonObject | readonly JsonValue[];
 export type JsonObject = {
@@ -24,226 +21,5 @@ export interface ContextItem {
 export interface Tripwire {
     readonly code: string;
     readonly message: string;
-    readonly scope?: "step" | "session";
+    readonly scope?: "step" | "execution";
 }
-export interface ObserveToolSnapshot {
-    readonly name: string;
-    readonly description?: string;
-    readonly owner: {
-        readonly middlewareId: string;
-        readonly slot: string;
-    };
-    readonly inputSchema: {
-        readonly jsonSchema: JsonObject;
-    };
-    readonly outputSchema?: {
-        readonly jsonSchema: JsonObject;
-    };
-}
-/** JSON-only model-configuration view suitable for an observation stream. */
-export interface ObserveModelConfigurationSnapshot extends Omit<ModelConfigurationSnapshot, "tools"> {
-    readonly tools: readonly ObserveToolSnapshot[];
-}
-export interface ObserveSealedCall {
-    readonly callId: string;
-    readonly toolName: string;
-    readonly args: JsonValue;
-    readonly invocationId: string;
-    readonly owner: {
-        readonly middlewareId: string;
-        readonly slot: string;
-    };
-    readonly interaction?: RequiredInteraction;
-}
-export interface ObserveModelRequested {
-    /** The exact immutable logical input supplied to the ModelAdapter. */
-    readonly call: ModelCall;
-    /** Canonical configuration facts and attribution. */
-    readonly configuration: ObserveModelConfigurationSnapshot;
-    /** Current-step runtime context and attribution. */
-    readonly context: ContextSnapshot;
-}
-export type ObserveEvent = {
-    readonly type: "session.stopped";
-    readonly reason: string;
-} | {
-    readonly type: "capability.state.dispose.failed";
-    readonly capabilityId: string;
-    readonly attributes: {
-        readonly message: string;
-    };
-} | {
-    readonly type: "session.seeded";
-    readonly revision: number;
-    readonly transcriptEntries: number;
-} | {
-    readonly type: "session.continued";
-    readonly inputId?: string;
-} | {
-    readonly type: "session.record.failed";
-    readonly code: string;
-    readonly attributes: {
-        readonly message: string;
-    };
-} | {
-    readonly type: "input.received";
-    readonly inputId: string;
-    readonly kind: string;
-} | {
-    readonly type: "input.queued";
-    readonly inputId: string;
-} | {
-    readonly type: "input.rejected";
-    readonly inputId: string;
-    readonly reason: string;
-} | {
-    readonly type: "input.cancelled";
-    readonly inputId: string;
-    readonly reason: string;
-} | {
-    readonly type: "model.requested";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly requestedModelId?: string;
-    readonly attributes: ObserveModelRequested;
-} | {
-    readonly type: "model.prepared";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly requestedModelId?: string;
-    readonly attributes: {
-        readonly adapter: string;
-        readonly call: JsonValue;
-    };
-} | {
-    readonly type: "model.completed";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly requestedModelId?: string;
-    readonly attributes: ModelCandidate;
-} | {
-    readonly type: "model.deferred";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly invocationId: string;
-    readonly attributes: {
-        readonly token?: JsonValue;
-    };
-} | {
-    readonly type: "step.started";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly turnNumber: number;
-    readonly stepNumber: number;
-    readonly attributes: {
-        readonly session?: {
-            readonly userId?: string;
-            readonly context?: JsonObject;
-        };
-        readonly arrivals: readonly InputEvent[];
-        readonly toolResults: readonly ToolResult[];
-        readonly transcript: readonly TranscriptEntry[];
-    };
-} | {
-    readonly type: "middleware.entered" | "middleware.completed";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly middlewareId: string;
-} | {
-    readonly type: "middleware.lease-violation";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly middlewareId: string;
-    readonly reason: string;
-} | {
-    readonly type: "tool.sealed";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly attributes: {
-        readonly executable: readonly ObserveSealedCall[];
-        readonly immediate: readonly ToolResult[];
-    };
-} | {
-    readonly type: "tool.started";
-    readonly sessionId: string;
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly toolName: string;
-    readonly callId: string;
-    readonly invocationId: string;
-    readonly middlewareId: string;
-    readonly slot: string;
-    readonly attributes: {
-        readonly args: JsonValue;
-    };
-} | {
-    readonly type: "tool.completed";
-    readonly sessionId: string;
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly toolName: string;
-    readonly callId: string;
-    readonly invocationId: string;
-    readonly middlewareId: string;
-    readonly slot: string;
-    readonly outcome: string;
-    readonly code?: string;
-    readonly attributes?: ToolResult;
-} | {
-    readonly type: "tool.deferred";
-    readonly sessionId: string;
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly toolName: string;
-    readonly callId: string;
-    readonly invocationId: string;
-    readonly middlewareId: string;
-    readonly slot: string;
-    readonly attributes: {
-        readonly token?: JsonValue;
-    };
-} | {
-    readonly type: "turn.completed";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly attributes: {
-        readonly output: JsonValue;
-    };
-} | {
-    readonly type: "interaction.required";
-    readonly turnId: string;
-    readonly stepId: string;
-    readonly inputId?: string;
-    readonly interactionId: string;
-    readonly kind: string;
-    readonly callId?: string;
-    readonly toolName?: string;
-    readonly phase?: "interaction" | "execute";
-    readonly attributes: {
-        readonly prompt: string;
-        readonly metadata?: JsonObject;
-    };
-} | {
-    readonly type: "tripwire";
-    readonly turnId: string;
-    readonly stepId?: string;
-    readonly inputId?: string;
-    readonly code: string;
-    readonly scope: string;
-    readonly attributes: {
-        readonly message: string;
-    };
-};
-export type Observer = (event: ObserveEvent) => void | Promise<void>;

package/dist/types/tool.d.ts

@@ -43,21 +43,13 @@ export type ToolSchemaSource<T = unknown> = ZodType<T> | StandardToolSchema<any,
 export type SchemaOutput<Schema> = Schema extends ZodType<infer Value> ? Value : Schema extends StandardToolSchema<any, infer Value> ? Value : Schema extends ToolSchema<infer Value> ? Value : never;
 export type ToolInputSchema = ToolSchemaSource;
 export type ToolOutputSchema = ToolSchemaSource;
-export interface BoundToolSchema<T> extends ToolSchema<T> {
-}
 type OutputFor<Schema> = Schema extends ToolSchemaSource ? SchemaOutput<Schema> : ToolContent;
-export interface ToolDefinition<InputSchema extends ToolInputSchema = ToolInputSchema, State = never, OutputSchema extends ToolOutputSchema | undefined = undefined> {
+export interface ToolDefinition<InputSchema extends ToolInputSchema = ToolInputSchema, Info = unknown, OutputSchema extends ToolOutputSchema | undefined = undefined> {
     readonly name: string;
     readonly description?: string;
     readonly inputSchema: InputSchema;
     readonly outputSchema?: OutputSchema;
-    execute(args: SchemaOutput<InputSchema>, context: ToolExecutionContext<State>): Promise<ToolOutcome<OutputFor<OutputSchema>>>;
-}
-export interface BoundToolDefinition<State = never> extends Omit<ToolDefinition<ToolInputSchema, State, ToolOutputSchema | undefined>, "inputSchema" | "outputSchema" | "execute"> {
-    readonly inputSchema: BoundToolSchema<unknown>;
-    readonly outputSchema?: BoundToolSchema<unknown>;
-    readonly execute: (args: unknown, context: ToolExecutionContext<State>) => Promise<ToolOutcome>;
-    readonly owner: ToolOwner;
+    execute(args: SchemaOutput<InputSchema>, context: ToolExecutionContext<Info>): Promise<ToolOutcome<OutputFor<OutputSchema>>>;
 }
 export interface ToolOwner {
     readonly middlewareId: string;
@@ -79,25 +71,20 @@ export interface ToolExecutionResume {
     readonly value?: JsonValue;
     readonly token?: JsonValue;
 }
-export interface SealedToolCall {
-    readonly callId: string;
-    readonly toolName: string;
-    readonly args: JsonValue;
-}
 interface ToolExecutionContextBase {
-    readonly sessionId: string;
+    readonly executionId: string;
     readonly turnId: string;
     readonly stepId: string;
     readonly callId: string;
     readonly invocationId: string;
     readonly signal: AbortSignal;
-    /** The session's model callable, for tools that explicitly run a child agent. */
+    /** The invocation's model callable, for tools that explicitly run a child agent. */
     readonly onModelCall?: ModelAdapter;
     readonly resume?: ToolExecutionResume;
 }
-export type ToolExecutionContext<State = never> = ToolExecutionContextBase & ([State] extends [never] ? object : {
-    readonly state: Promise<State>;
-});
+export type ToolExecutionContext<Info = unknown> = ToolExecutionContextBase & {
+    readonly info?: Info;
+};
 export type ToolContent = JsonValue;
 export type ToolOutcome<Output = ToolContent> = {
     readonly kind: "completed";
@@ -136,4 +123,16 @@ export type ToolResult = {
     readonly message: string;
     readonly details?: ToolValidationFailureDetails;
 };
+/** Immutable tool metadata supplied to model adapters and observers. */
+export interface ToolDescriptor {
+    readonly name: string;
+    readonly description?: string;
+    readonly owner: ToolOwner;
+    readonly inputSchema: {
+        readonly jsonSchema: JsonObject;
+    };
+    readonly outputSchema?: {
+        readonly jsonSchema: JsonObject;
+    };
+}
 export {};

package/dist/types/transcript.d.ts

@@ -0,0 +1,65 @@
+import type { ModelCandidate } from "./model.js";
+import type { JsonObject, JsonValue } from "./shared.js";
+import type { ToolResult } from "./tool.js";
+export type InputEvent = {
+    readonly kind: "user-message" | "interrupt";
+    readonly text: string;
+    readonly metadata?: JsonObject;
+} | {
+    readonly kind: "user-message" | "interrupt";
+    readonly content: readonly UserContentPart[];
+    /** Undefined for content-bearing events; retained for text-event narrowing compatibility. */
+    readonly text?: undefined;
+    readonly metadata?: JsonObject;
+} | {
+    readonly kind: "approve";
+    readonly interactionId: string;
+    readonly approved: boolean;
+} | {
+    readonly kind: "respond";
+    readonly interactionId: string;
+    readonly value: JsonValue;
+};
+/** Ordered, model-visible user content. Media references stay host-owned JSON values. */
+export type UserContentPart = {
+    readonly type: "text";
+    readonly text: string;
+} | {
+    readonly type: "media";
+    readonly mediaType: string;
+    readonly reference: JsonValue;
+};
+export type MessageInput = string | {
+    readonly text: string;
+    readonly metadata?: JsonObject;
+} | {
+    readonly content: readonly UserContentPart[];
+    readonly metadata?: JsonObject;
+};
+export type InteractionReply = Extract<InputEvent, {
+    kind: "approve" | "respond";
+}>;
+export interface TranscriptInputEntry {
+    readonly kind: "input";
+    readonly turnId: string;
+    readonly event: InputEvent;
+}
+export interface TranscriptCandidateEntry {
+    readonly kind: "candidate";
+    readonly turnId: string;
+    readonly stepId: string;
+    readonly candidate: ModelCandidate;
+}
+export interface TranscriptToolsEntry {
+    readonly kind: "tool-results";
+    readonly turnId: string;
+    readonly stepId: string;
+    readonly results: readonly ToolResult[];
+}
+export interface TranscriptFinalEntry {
+    readonly kind: "final";
+    readonly turnId: string;
+    readonly stepId: string;
+    readonly output: JsonValue;
+}
+export type TranscriptEntry = TranscriptInputEntry | TranscriptCandidateEntry | TranscriptToolsEntry | TranscriptFinalEntry;

package/dist/types/transcript.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/canonical.d.ts

@@ -0,0 +1 @@
+export declare function canonical(value: unknown): string;

package/dist/utils/canonical.js

@@ -0,0 +1,10 @@
+export function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(",")}]`;
+    if (value && typeof value === "object")
+        return `{${Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`)
+            .join(",")}}`;
+    return JSON.stringify(value);
+}

package/dist/utils/immutable.d.ts

@@ -3,3 +3,4 @@ export declare function assertJson(value: unknown, path?: string): asserts value
 export declare function copyJson<T>(value: T): T;
 export declare function copyJsonObject(value: unknown, path: string): JsonObject;
 export declare function deepFreeze<T>(value: T): T;
+export declare function freezeGraph<T>(value: T, seen?: WeakSet<object>): T;

package/dist/utils/immutable.js

@@ -66,3 +66,11 @@ export function deepFreeze(value) {
     }
     return value;
 }
+export function freezeGraph(value, seen = new WeakSet()) {
+    if (!value || typeof value !== "object" || seen.has(value))
+        return value;
+    seen.add(value);
+    for (const item of Object.values(value))
+        freezeGraph(item, seen);
+    return Object.freeze(value);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/harness",
-  "version": "0.12.0-beta",
+  "version": "0.13.0-beta",
   "description": "Nylorun's TypeScript agent runtime. See github.com/nylorun/harness.",
   "type": "module",
   "license": "Apache-2.0",
@@ -29,8 +29,8 @@
       "import": "./dist/index.js"
     },
     "./model/adapters": {
-      "types": "./dist/model/adapters.d.ts",
-      "import": "./dist/model/adapters.js"
+      "types": "./dist/execution/model/adapters.d.ts",
+      "import": "./dist/execution/model/adapters.js"
     }
   },
   "files": [

package/dist/build/agent.d.ts

@@ -1,17 +0,0 @@
-import type { AgentManifest } from "../types/manifest.js";
-import type { BoundMiddleware } from "../types/middleware.js";
-import type { ModelAdapter } from "../types/model.js";
-import type { Session, SessionRunOptions } from "../types/session.js";
-export interface LoopAgent {
-    readonly middleware: readonly BoundMiddleware[];
-    readonly invoke: ModelAdapter;
-}
-export declare class BuiltAgent {
-    readonly middleware: readonly BoundMiddleware[];
-    readonly manifest: AgentManifest;
-    readonly id: string;
-    readonly name: string;
-    private constructor();
-    run(options: SessionRunOptions): Session;
-}
-export declare function bindAgent(middleware: readonly BoundMiddleware[], manifest: AgentManifest): BuiltAgent;

package/dist/build/agent.js

@@ -1,32 +0,0 @@
-import { LiveSession } from "../session/session.js";
-import { createId } from "../utils/ids.js";
-import { HarnessError } from "../errors.js";
-let createBoundAgent;
-export class BuiltAgent {
-    middleware;
-    manifest;
-    id;
-    name;
-    constructor(middleware, manifest) {
-        this.middleware = middleware;
-        this.manifest = manifest;
-        this.id = manifest.id;
-        this.name = manifest.name;
-    }
-    static {
-        createBoundAgent = (middleware, manifest) => new BuiltAgent(middleware, manifest);
-    }
-    run(options) {
-        const seeded = "seed" in options && options.seed !== undefined;
-        if (seeded &&
-            (("id" in options && options.id !== undefined) ||
-                ("userId" in options && options.userId !== undefined) ||
-                ("context" in options && options.context !== undefined)))
-            throw new HarnessError("session.invalid-seed", "Seeded run options cannot include id, userId, or context outside the seed");
-        const id = (seeded ? options.seed.id : "id" in options ? options.id : undefined) ?? createId("session");
-        return new LiveSession(id, Object.freeze({ middleware: this.middleware, invoke: options.onModelCall }), options);
-    }
-}
-export function bindAgent(middleware, manifest) {
-    return createBoundAgent(middleware, manifest);
-}

package/dist/build/assemble.d.ts

@@ -1,7 +0,0 @@
-import type { BuildResult } from "../types/manifest.js";
-import type { BoundMiddleware } from "../types/middleware.js";
-import { type BuiltAgent } from "./agent.js";
-export declare function assembleAgent(middleware: readonly BoundMiddleware[], identity: Readonly<{
-    id: string;
-    name: string;
-}>): BuildResult<BuiltAgent>;

package/dist/build/builder.d.ts

@@ -1,38 +0,0 @@
-import type { BoundMiddleware, CapabilityDeclaration, StepMiddleware } from "../types/middleware.js";
-import type { BuildDiagnostic } from "../types/shared.js";
-import { HarnessError } from "../errors.js";
-import type { BuiltAgent } from "./agent.js";
-export interface AgentOptions {
-    readonly id: string;
-    readonly name: string;
-    readonly instructions?: string | readonly string[];
-}
-interface BuilderState {
-    readonly id: string;
-    readonly name: string;
-    readonly middleware: BoundMiddleware[];
-    sealed: boolean;
-    agent?: BuiltAgent;
-    error?: AgentBuildError;
-    middlewareSeq: number;
-}
-export declare class AgentBuildError extends HarnessError {
-    readonly diagnostics: readonly BuildDiagnostic[];
-    constructor(diagnostics: readonly BuildDiagnostic[]);
-}
-export declare class AgentLifecycleError extends HarnessError {
-    constructor(message: string);
-}
-export declare function Agent(options: AgentOptions): AgentBuilder;
-export declare class AgentBuilder {
-    private readonly state;
-    constructor(state: BuilderState);
-    use(middleware: StepMiddleware): this;
-    use(id: string, middleware: StepMiddleware): this;
-    use<State>(declaration: CapabilityDeclaration<State>): this;
-    build(): BuiltAgent;
-    private nextMiddlewareId;
-    private push;
-    private assertOpen;
-}
-export {};

package/dist/build/builder.js

@@ -1,136 +0,0 @@
-import { HarnessError } from "../errors.js";
-import { assembleAgent } from "./assemble.js";
-export class AgentBuildError extends HarnessError {
-    diagnostics;
-    constructor(diagnostics) {
-        super("agent.build-failed", diagnostics.map((item) => item.message).join("; ") || "Agent build failed");
-        this.diagnostics = diagnostics;
-        this.name = "AgentBuildError";
-    }
-}
-export class AgentLifecycleError extends HarnessError {
-    constructor(message) {
-        super("agent.lifecycle-sealed", message);
-        this.name = "AgentLifecycleError";
-    }
-}
-export function Agent(options) {
-    return new AgentBuilder(createState(options));
-}
-export class AgentBuilder {
-    state;
-    constructor(state) {
-        this.state = state;
-    }
-    use(idOrMiddleware, middleware) {
-        if (typeof idOrMiddleware === "function") {
-            return this.push({ id: this.nextMiddlewareId(), handle: idOrMiddleware });
-        }
-        if (typeof idOrMiddleware === "object")
-            return this.push(compileDeclaration(idOrMiddleware));
-        return this.push({ id: idOrMiddleware, handle: middleware });
-    }
-    build() {
-        if (this.state.agent)
-            return this.state.agent;
-        if (this.state.error)
-            throw this.state.error;
-        this.state.sealed = true;
-        const result = assembleAgent(this.state.middleware, {
-            id: this.state.id,
-            name: this.state.name,
-        });
-        if (!result.ok) {
-            this.state.error = new AgentBuildError(result.diagnostics);
-            throw this.state.error;
-        }
-        this.state.agent = result.agent;
-        return this.state.agent;
-    }
-    nextMiddlewareId() {
-        const taken = new Set(this.state.middleware.map((item) => item.id));
-        let id;
-        do {
-            this.state.middlewareSeq += 1;
-            id = `middleware-${this.state.middlewareSeq}`;
-        } while (taken.has(id));
-        return id;
-    }
-    push(entry) {
-        this.assertOpen();
-        this.state.middleware.push(entry);
-        return this;
-    }
-    assertOpen() {
-        if (this.state.sealed)
-            throw new AgentLifecycleError("AgentBuilder cannot be changed after build()");
-    }
-}
-function createState(options) {
-    const middleware = [];
-    if (options.instructions !== undefined) {
-        const instructions = typeof options.instructions === "string" ? [options.instructions] : options.instructions;
-        middleware.push(compileDeclaration({ id: "agent", instructions }));
-    }
-    return {
-        id: options.id,
-        name: options.name,
-        middleware,
-        sealed: false,
-        middlewareSeq: 0,
-    };
-}
-function compileDeclaration(declaration) {
-    const tools = copyItems(declaration.tools, declaration.id);
-    const instructions = copyItems(declaration.instructions, declaration.id);
-    const model = declaration.model;
-    const contributions = snapshotContributions(instructions?.items, tools?.items, model);
-    const handle = async (request, next) => {
-        if (tools)
-            request.configuration.tools.set(tools.slot, tools.items);
-        if (instructions)
-            request.configuration.instructions.set(instructions.slot, instructions.items);
-        if (model)
-            request.configuration.model.select(model);
-        return declaration.middleware ? declaration.middleware(request, next) : next();
-    };
-    return {
-        id: declaration.id,
-        handle,
-        ...(declaration.state === undefined
-            ? {}
-            : { state: declaration.state }),
-        ...(contributions === undefined ? {} : { contributions }),
-    };
-}
-function snapshotContributions(instructions, tools, model) {
-    const snapInstructions = instructions === undefined ? undefined : Object.freeze([...instructions]);
-    const snapTools = tools === undefined
-        ? undefined
-        : Object.freeze(tools.map((tool) => Object.freeze({
-            name: tool.name,
-            ...(tool.description === undefined ? {} : { description: tool.description }),
-        })));
-    const snapModel = model === undefined ? undefined : snapshotModel(model);
-    if (snapInstructions === undefined && snapTools === undefined && snapModel === undefined) {
-        return undefined;
-    }
-    return Object.freeze({
-        ...(snapInstructions === undefined ? {} : { instructions: snapInstructions }),
-        ...(snapTools === undefined ? {} : { tools: snapTools }),
-        ...(snapModel === undefined ? {} : { model: snapModel }),
-    });
-}
-function snapshotModel(model) {
-    return Object.freeze({
-        ...(model.id === undefined ? {} : { id: model.id }),
-        ...(model.controls === undefined ? {} : { controls: Object.freeze({ ...model.controls }) }),
-    });
-}
-function copyItems(value, defaultSlot) {
-    if (value === undefined)
-        return undefined;
-    if (!("items" in value))
-        return Object.freeze({ slot: defaultSlot, items: Object.freeze([...value]) });
-    return Object.freeze({ slot: value.slot, items: Object.freeze([...value.items]) });
-}

package/dist/build/manifest.js

@@ -1,20 +0,0 @@
-import { deepFreeze } from "../utils/immutable.js";
-export function createManifest(input) {
-    const middleware = input.middleware.map((item) => projectMiddleware(item));
-    return deepFreeze({
-        id: input.id,
-        name: input.name,
-        middleware,
-    });
-}
-function projectMiddleware(item) {
-    const contributions = item.contributions;
-    return {
-        id: item.id,
-        ...(contributions?.instructions === undefined
-            ? {}
-            : { instructions: contributions.instructions }),
-        ...(contributions?.tools === undefined ? {} : { tools: contributions.tools }),
-        ...(contributions?.model === undefined ? {} : { model: contributions.model }),
-    };
-}