@shardflux/sdk 0.7.0 → 0.9.0

package/dist/workspace.d.ts

@@ -6,11 +6,12 @@ import type { ClientContext, DiskLayout, ForkTarget, Operation, WaitOptions, Wor
 import { CAPTURE_BARRIER, CellClient } from './cell.js';
 import { ToolCallCapture } from './capture.js';
 import type { ToolCallCaptureOptions } from './capture.js';
-import type { FinishedOperation, LifecycleOptions, WaitedLifecycleOptions } from './lifecycle.js';
+import type { WorkspaceMode } from './errors.js';
+import type { FinishedOperation, LifecycleOptions, ResumeOptions, WaitedLifecycleOptions, WaitedResumeOptions } from './lifecycle.js';
 import { Trace } from './progress.js';
 import type { LifecycleTiming, ProgressListener } from './progress.js';
 import { WorkspaceSecrets } from './secrets.js';
-import type { CellClientOptions, WorkspaceChangesPage, WorkspaceChangesParams } from './cell.js';
+import type { CellClientOptions, Residency, WorkspaceChangesPage, WorkspaceChangesParams } from './cell.js';
 import type { SaveAsTemplateParams, SaveAsTemplateResponse, WorkspaceStartup } from './templates.js';
 import { ToolTokenManager } from './tokens.js';
 import type { ToolName, ToolToken } from './tokens.js';
@@ -20,6 +21,38 @@ export interface WakeOptions {
     signal?: AbortSignal;
     /** Progress of the wake: the resume request, observed states, conflicts retried, and `done` with the timing. */
     onProgress?: ProgressListener;
+    /**
+     * The tool token the wake brings back (0.9.0): the held resume (contracts §22.6) returns one with the running
+     * workspace, for this agent label and tool set (defaults: those given to open()). It is kept for `cell()` clients of
+     * the same label and tools, whose next call then needs no token request. A `cell()` client's own wake passes its
+     * label and tools.
+     */
+    agentLabel?: string;
+    tools?: ToolName[];
+}
+export interface HintOptions {
+    /** The tool token to use: the agent label and tool set of `cell()` (defaults: those given to open()). */
+    agentLabel?: string;
+    tools?: ToolName[];
+    /**
+     * When the workspace is not running: how to wake it in the background. Default `workspace.wake()`; `null` does not
+     * wake it; a function replaces the wake (the same hook as `CellClientOptions.wake`).
+     */
+    wake?: CellClientOptions['wake'];
+    /** Bound on the background wake (default 120 000 ms). */
+    wakeTimeoutMs?: number;
+    signal?: AbortSignal;
+}
+/** `workspace.hint()`: what the host found, or the background wake of a workspace that was not running. */
+export interface HintResult {
+    /** The VM's residency when the hint arrived (contracts §25.1); null when the workspace was not running. */
+    residency: Residency | null;
+    /**
+     * The wake started in the background because the workspace was not running (409 `workspace_not_running`), else null.
+     * It resolves like `wake()`; nothing needs to await it (a failure is then left to the next tool call, which wakes
+     * the workspace itself), and concurrent hints share one wake.
+     */
+    wake: Promise<boolean> | null;
 }
 export declare class Workspace {
     #private;
@@ -69,6 +102,27 @@ export declare class Workspace {
     get startup(): WorkspaceStartup | null;
     /** The raw view (GET /v1/workspaces/{id}). */
     get data(): WorkspaceView;
+    /**
+     * `processful` (one VM keeps processes, memory and files) or `file_first` (0.9.0; contracts §29: a versioned file
+     * tree, commands run as executions). Immutable. A view without the field (older API) is processful.
+     */
+    get mode(): WorkspaceMode;
+    /**
+     * File-first workspaces: the newest tree revision this handle has seen (0 when created; each mutating files call or
+     * execution that changed something publishes the next). It follows every response of this handle's cell clients
+     * (`X-Tree-Revision`), execution results and refresh(); another writer's changes appear once a response reports
+     * them. Pass it as `ifTreeRevision` to make a write conditional. Null for processful workspaces.
+     */
+    get treeRevision(): number | null;
+    /**
+     * Executions of this file-first workspace (contracts §29.8) through `cell()`'s default client: `run(argv, opts)` runs
+     * a command in a fresh VM on the latest tree and returns an ExecutionResult (output, exit code, `changed`,
+     * `treeRevision`); `get(id, { waitMs })` reads one. See CellClient.executions.
+     *
+     *   const r = await workspace.executions.run(['bash', '-lc', 'pytest -q'], { timeoutMs: 600_000 });
+     *   console.log(r.exitCode, r.stdoutText, r.changed, r.treeRevision);
+     */
+    get executions(): CellClient['executions'];
     /** Secret names bound to this workspace (injected into every exec/PTY start): `get()`, `set(names)`. */
     get secrets(): WorkspaceSecrets;
     /** The workspace's text inputs `{NAME: value}` (0.7.0; secret inputs are bound secrets, never listed here). */
@@ -93,10 +147,13 @@ export declare class Workspace {
     suspend(opts?: LifecycleOptions): Promise<Operation>;
     /**
      * Resumes a suspended workspace. Resolves when the resume is REQUESTED; with `{ wait: true }`, once the workspace runs.
-     * Tool calls wake a suspended workspace by themselves, so this is rarely needed.
+     * Tool calls wake a suspended workspace by themselves, so this is rarely needed. With `wait` (0.9.0) it is one held
+     * request (contracts §22.6): the handle takes the running view and a tool token for `agentLabel`/`tools` (defaults:
+     * those given to open()), so `cell()` calls with that label and tools start at once. A workspace that is already
+     * running is ShardfluxApiError 409 `conflict` (`already_running`).
      */
-    resume(opts: WaitedLifecycleOptions): Promise<FinishedOperation>;
-    resume(opts?: LifecycleOptions): Promise<Operation>;
+    resume(opts: WaitedResumeOptions): Promise<FinishedOperation>;
+    resume(opts?: ResumeOptions): Promise<Operation>;
     /** Takes a snapshot. Resolves when it is REQUESTED; with `{ wait: true }`, once it is taken. */
     snapshot(opts: WaitedLifecycleOptions & {
         label?: string;
@@ -151,6 +208,7 @@ export declare class Workspace {
     /**
      * The workspace's changes against its template (cell gateway GET /v1/workspaces/{id}/changes; needs the `files` tool).
      * 409 workspace_not_running, or conflict with details.reason legacy_disk_layout / guest_feature_unavailable.
+     * File-first workspaces: NotSupportedForModeError (each execution result lists what it changed).
      */
     changes(opts?: WorkspaceChangesParams & {
         agentLabel?: string;
@@ -180,8 +238,22 @@ export declare class Workspace {
      * operation_in_progress) at once. Cell calls use it automatically when they meet `workspace_not_running`. A resume no
      * host admits within 15 minutes fails with `capacity_unavailable` (OperationFailedError, `retryable`: the workspace
      * stays suspended with its state; try again later).
+     *
+     * Since 0.9.0 the resume is held by the server until the workspace runs (contracts §22.6): one request returns the
+     * running workspace and a tool token for `agentLabel`/`tools`, which this handle keeps, so a tool call that woke the
+     * workspace is retried at once (refused call, resume, call). Timing: one `request` phase with reason `held`. A server
+     * that does not hold the request answers at once; the wake then waits for the operation and reads the view.
      */
     wake(opts?: WakeOptions): Promise<boolean>;
+    /**
+     * Announces an imminent tool call (cell `POST /wake-hint`, contracts §26.6; 0.9.0+) so a parked workspace is restored
+     * ahead of it: call it when the model starts emitting a tool call, before its arguments are complete. The agent tools
+     * of `workspaceTools()` send it when a call starts. Cheap and best effort: it returns what the host found. A workspace
+     * that is not running (suspended, or a token cannot be issued for it) is woken in the background (`wake`, not awaited
+     * here) so the call finds it running sooner. Other errors (network, auth) are thrown; callers that fire and forget
+     * should catch them.
+     */
+    hint(opts?: HintOptions): Promise<HintResult>;
     /** Tools granted by the most recent token (null before one was issued). */
     get grantedTools(): ToolName[] | null;
 }

package/dist/workspace.js

@@ -1,13 +1,16 @@
 import { CAPTURE_BARRIER, CellClient, DEFAULT_TRANSITION_TIMEOUT_MS } from "./cell.js";
 import { ToolCallCapture } from "./capture.js";
-import { OperationFailedError, ShardfluxApiError } from "./errors.js";
-import { defaultSleep, randomId } from "./http.js";
-import { AFTER_WAIT, TRACE } from "./lifecycle.js";
+import { NotSupportedForModeError, OperationFailedError, ShardfluxApiError } from "./errors.js";
+import { SERVER_WAIT_MAX_S, defaultSleep, randomId } from "./http.js";
+import { AFTER_WAIT, HELD_RESUME, TRACE } from "./lifecycle.js";
 import { Trace, combineListeners, traced } from "./progress.js";
 import { WorkspaceSecrets } from "./secrets.js";
 import { ToolTokenManager } from "./tokens.js";
+const notRunning = (e) => e instanceof ShardfluxApiError && (e.code === 'workspace_not_running' || (e.code === 'conflict' && e.reason === 'workspace_not_running'));
 export class Workspace {
     #view;
+    /** The background wake started by hint(), shared by concurrent hints until it settles. */
+    #hintWake = null;
     #ctx;
     #defaults;
     #managers = new Map();
@@ -15,14 +18,27 @@ export class Workspace {
     /** The open() that produced this handle; its timing is final once open() has returned. */
     #openTrace;
     #lastTiming;
+    /** The newest tree revision seen (file-first): the view's, or any cell response's since. */
+    #treeRevision;
     constructor(ctx, view, opts = {}) {
         this.#ctx = ctx;
         this.#view = view;
+        this.#treeRevision = view.mode === 'file_first' && typeof view.tree_revision === 'number' ? view.tree_revision : null;
         this.#defaults = { agentLabel: opts.agentLabel, tools: opts.tools };
         this.#openTrace = opts.trace;
         if (opts.token)
             this.tokens().seed(opts.token);
     }
+    #noteTreeRevision(rev) {
+        if (this.#treeRevision === null || rev > this.#treeRevision)
+            this.#treeRevision = rev;
+    }
+    /** The local refusal of a lifecycle call a file-first workspace does not have (contracts §29.7). */
+    #needsVm(operation) {
+        if (this.#view.mode !== 'file_first')
+            return null;
+        return NotSupportedForModeError.local('file_first', operation, 'api', `${operation} is not available for a file-first workspace: it has no VM between executions and is never suspended; its state is its file tree (workspace.treeRevision).`);
+    }
     /**
      * Where the time went in the last lifecycle call made through this handle: open(), wake() (also when a tool call
      * woke the workspace), or a lifecycle call with `wait`. Null for handles from get()/list() until such a call.
@@ -120,6 +136,33 @@ export class Workspace {
     get data() {
         return this.#view;
     }
+    /**
+     * `processful` (one VM keeps processes, memory and files) or `file_first` (0.9.0; contracts §29: a versioned file
+     * tree, commands run as executions). Immutable. A view without the field (older API) is processful.
+     */
+    get mode() {
+        return this.#view.mode ?? 'processful';
+    }
+    /**
+     * File-first workspaces: the newest tree revision this handle has seen (0 when created; each mutating files call or
+     * execution that changed something publishes the next). It follows every response of this handle's cell clients
+     * (`X-Tree-Revision`), execution results and refresh(); another writer's changes appear once a response reports
+     * them. Pass it as `ifTreeRevision` to make a write conditional. Null for processful workspaces.
+     */
+    get treeRevision() {
+        return this.mode === 'file_first' ? this.#treeRevision : null;
+    }
+    /**
+     * Executions of this file-first workspace (contracts §29.8) through `cell()`'s default client: `run(argv, opts)` runs
+     * a command in a fresh VM on the latest tree and returns an ExecutionResult (output, exit code, `changed`,
+     * `treeRevision`); `get(id, { waitMs })` reads one. See CellClient.executions.
+     *
+     *   const r = await workspace.executions.run(['bash', '-lc', 'pytest -q'], { timeoutMs: 600_000 });
+     *   console.log(r.exitCode, r.stdoutText, r.changed, r.treeRevision);
+     */
+    get executions() {
+        return this.cell().executions;
+    }
     /** Secret names bound to this workspace (injected into every exec/PTY start): `get()`, `set(names)`. */
     get secrets() {
         return new WorkspaceSecrets(this.#ctx, this.id);
@@ -130,6 +173,8 @@ export class Workspace {
     }
     async refresh() {
         this.#view = await this.#ctx.http.json('GET', `/v1/workspaces/${encodeURIComponent(this.id)}`, {}, this.#ctx.authorization);
+        if (this.#view.mode === 'file_first' && typeof this.#view.tree_revision === 'number')
+            this.#noteTreeRevision(this.#view.tree_revision);
         return this;
     }
     /** Waits for the active operation (if any) and refreshes. */
@@ -143,15 +188,41 @@ export class Workspace {
         return this.#ctx.workspaces.delete(this.id, { ...this.#tracked(opts), [AFTER_WAIT]: this.#refreshAfterWait() });
     }
     suspend(opts = {}) {
+        const refusal = this.#needsVm('suspend');
+        if (refusal)
+            return Promise.reject(refusal);
         return this.#ctx.workspaces.suspend(this.id, { ...this.#tracked(opts), [AFTER_WAIT]: this.#refreshAfterWait() });
     }
     resume(opts = {}) {
-        return this.#ctx.workspaces.resume(this.id, { ...this.#tracked(opts), [AFTER_WAIT]: this.#refreshAfterWait() });
+        const refusal = this.#needsVm('resume');
+        if (refusal)
+            return Promise.reject(refusal);
+        // With `wait` the held resume's view and token go straight into this handle (the token for agentLabel/tools).
+        const manager = this.tokens({ ...(opts.agentLabel !== undefined ? { agentLabel: opts.agentLabel } : {}), ...(opts.tools !== undefined ? { tools: opts.tools } : {}) });
+        return this.#ctx.workspaces.resume(this.id, { ...this.#tracked(opts), [AFTER_WAIT]: this.#refreshAfterWait(), [HELD_RESUME]: this.#heldTarget(manager) });
+    }
+    /** A held resume's 200 (contracts §22.6) goes straight into this handle: the view, and the token for `manager`. */
+    #heldTarget(manager) {
+        return {
+            agentLabel: manager.agentLabel,
+            tools: manager.tools,
+            adopt: (view, token) => {
+                this.#view = view;
+                if (token)
+                    manager.seed(token);
+            },
+        };
     }
     snapshot(opts = {}) {
+        const refusal = this.#needsVm('snapshot');
+        if (refusal)
+            return Promise.reject(refusal);
         return this.#ctx.workspaces.snapshot(this.id, { ...this.#tracked(opts), [AFTER_WAIT]: this.#refreshAfterWait() });
     }
     fork(target, opts = {}) {
+        const refusal = this.#needsVm('fork');
+        if (refusal)
+            return Promise.reject(refusal);
         return this.#ctx.workspaces.fork(this.id, target, this.#tracked(opts));
     }
     async close(opts = {}) {
@@ -169,6 +240,9 @@ export class Workspace {
         return out.operation;
     }
     async reset(opts = {}) {
+        const refusal = this.#needsVm('reset');
+        if (refusal)
+            throw refusal;
         const op = await this.#ctx.workspaces.reset(this.id, { ...this.#tracked(opts), [AFTER_WAIT]: this.#refreshAfterWait() });
         for (const m of this.#managers.values())
             m.invalidate();
@@ -197,7 +271,7 @@ export class Workspace {
             maxRetries: 0,
             ...(opts.transitionTimeoutMs !== undefined ? { transitionTimeoutMs: opts.transitionTimeoutMs } : {}),
             ...(this.#ctx.onProgress ? { onProgress: this.#ctx.onProgress } : {}),
-            wake: opts.wake === undefined ? (timeoutMs, signal) => this.wake({ timeoutMs, ...(signal ? { signal } : {}) }) : opts.wake,
+            wake: opts.wake === undefined ? (timeoutMs, signal) => this.wake({ timeoutMs, ...(signal ? { signal } : {}), ...(agentLabel !== undefined ? { agentLabel } : {}), ...(tools !== undefined ? { tools } : {}) }) : opts.wake,
         });
         return new ToolCallCapture({ workspaceId: this.id, cell, registry: this.#ctx.captures, ...(this.#ctx.sleep !== defaultSleep ? { sleep: this.#ctx.sleep } : {}) }, opts);
     }
@@ -207,11 +281,15 @@ export class Workspace {
     }
     /** Saves this layered workspace as the next version of an organization template (contracts §19.8). */
     saveAsTemplate(params) {
+        const refusal = this.#needsVm('save_as_template');
+        if (refusal)
+            return Promise.reject(refusal);
         return this.#ctx.workspaces.saveAsTemplate(this.id, params);
     }
     /**
      * The workspace's changes against its template (cell gateway GET /v1/workspaces/{id}/changes; needs the `files` tool).
      * 409 workspace_not_running, or conflict with details.reason legacy_disk_layout / guest_feature_unavailable.
+     * File-first workspaces: NotSupportedForModeError (each execution result lists what it changed).
      */
     changes(opts = {}) {
         const { agentLabel, tools, ...params } = opts;
@@ -249,8 +327,14 @@ export class Workspace {
                 userAgent: this.#ctx.userAgent,
                 sleep: this.#ctx.sleep,
                 ...cellOpts,
+                // The view's mode (undefined from an older API: calls are sent and the server decides).
+                mode: () => this.#view.mode,
+                onTreeRevision: (rev) => this.#noteTreeRevision(rev),
                 ...(listener ? { onProgress: listener } : {}),
-                wake: wake === undefined ? (timeoutMs, signal) => this.wake({ timeoutMs, ...(signal ? { signal } : {}), ...(onProgress ? { onProgress } : {}) }) : wake,
+                // The wake's held resume brings back this client's token (its label and tools).
+                wake: wake === undefined
+                    ? (timeoutMs, signal) => this.wake({ timeoutMs, ...(signal ? { signal } : {}), ...(onProgress ? { onProgress } : {}), ...(agentLabel !== undefined ? { agentLabel } : {}), ...(tools !== undefined ? { tools } : {}) })
+                    : wake,
                 [CAPTURE_BARRIER]: () => this.#ctx.captures.settle(this.id),
             });
             this.#cells.set(k, c);
@@ -267,8 +351,16 @@ export class Workspace {
      * operation_in_progress) at once. Cell calls use it automatically when they meet `workspace_not_running`. A resume no
      * host admits within 15 minutes fails with `capacity_unavailable` (OperationFailedError, `retryable`: the workspace
      * stays suspended with its state; try again later).
+     *
+     * Since 0.9.0 the resume is held by the server until the workspace runs (contracts §22.6): one request returns the
+     * running workspace and a tool token for `agentLabel`/`tools`, which this handle keeps, so a tool call that woke the
+     * workspace is retried at once (refused call, resume, call). Timing: one `request` phase with reason `held`. A server
+     * that does not hold the request answers at once; the wake then waits for the operation and reads the view.
      */
     async wake(opts = {}) {
+        // A file-first workspace runs from creation and is never suspended (contracts §29.7): nothing to wake.
+        if (this.#view.mode === 'file_first')
+            return false;
         const trace = new Trace('wake', combineListeners(this.#ctx.onProgress, this.#tracked(opts).onProgress), { workspaceId: this.id });
         return traced(trace, () => this.#wake(opts, trace));
     }
@@ -276,17 +368,39 @@ export class Workspace {
         const deadline = Date.now() + (opts.timeoutMs ?? DEFAULT_TRANSITION_TIMEOUT_MS);
         const waitFor = (operationId) => this.#ctx.workspaces.waitForOperation(operationId, { timeoutMs: Math.max(1, deadline - Date.now()), ...(opts.signal ? { signal: opts.signal } : {}), [TRACE]: trace });
         const resumePath = `/v1/workspaces/${encodeURIComponent(this.id)}/resume`;
+        // The held resume's token is for the caller's client (agent label and tools).
+        const target = this.#heldTarget(this.tokens({ ...(opts.agentLabel !== undefined ? { agentLabel: opts.agentLabel } : {}), ...(opts.tools !== undefined ? { tools: opts.tools } : {}) }));
         for (let i = 0; i < 4; i += 1) {
             if (opts.signal?.aborted)
                 throw opts.signal.reason;
             let active;
             try {
-                // Resume returns the active resume/open when there is one, so concurrent wakes join a single operation. The
-                // request is made here rather than through resume() so the wake is one trace.
-                trace.phase('request', i === 0 ? null : 'retry');
-                const { operation: op } = await this.#ctx.http.json('POST', resumePath, { idempotencyKey: randomId('op-'), onRetry: trace.onRetry }, this.#ctx.authorization);
-                trace.observe(op);
-                await waitFor(op.id);
+                // Held resume (contracts §22.6): answered once the workspace runs, with the view and a token; it returns the
+                // active resume/open when there is one, so concurrent wakes join a single operation. The request is made here
+                // rather than through resume() so the wake is one trace.
+                const waitS = Math.min(SERVER_WAIT_MAX_S, Math.floor((deadline - Date.now()) / 1000));
+                trace.phase('request', waitS >= 1 ? 'held' : i === 0 ? null : 'retry');
+                const answer = await this.#ctx.workspaces.requestResume(this.id, {
+                    waitS,
+                    agentLabel: target.agentLabel,
+                    tools: target.tools,
+                    idempotencyKey: randomId('op-'),
+                    signal: opts.signal,
+                    onRetry: trace.onRetry,
+                });
+                if (answer.operation)
+                    trace.observe(answer.operation);
+                if (answer.ready) {
+                    target.adopt(answer.workspace, answer.toolToken);
+                    // No operation: it was already running (after a conflict this wake did wait for an operation).
+                    return answer.operation !== null || i > 0;
+                }
+                // Not held (an older server), or not finished within the hold: wait for the operation, then read the view.
+                const op = answer.operation;
+                if (op.state === 'failed' || op.state === 'canceled')
+                    throw new OperationFailedError(op);
+                if (op.state !== 'succeeded')
+                    await waitFor(op.id);
                 await trace.span('view', () => this.refresh());
                 return true;
             }
@@ -318,6 +432,44 @@ export class Workspace {
         }
         throw new Error(`workspace ${this.id} did not become runnable after repeated lifecycle conflicts`);
     }
+    /**
+     * Announces an imminent tool call (cell `POST /wake-hint`, contracts §26.6; 0.9.0+) so a parked workspace is restored
+     * ahead of it: call it when the model starts emitting a tool call, before its arguments are complete. The agent tools
+     * of `workspaceTools()` send it when a call starts. Cheap and best effort: it returns what the host found. A workspace
+     * that is not running (suspended, or a token cannot be issued for it) is woken in the background (`wake`, not awaited
+     * here) so the call finds it running sooner. Other errors (network, auth) are thrown; callers that fire and forget
+     * should catch them.
+     */
+    async hint(opts = {}) {
+        // Nothing of a file-first workspace sleeps: resident, without a request.
+        if (this.#view.mode === 'file_first')
+            return { residency: 'resident', wake: null };
+        const { agentLabel, tools, signal } = opts;
+        try {
+            const r = await this.cell({ ...(agentLabel !== undefined ? { agentLabel } : {}), ...(tools !== undefined ? { tools } : {}), wake: null }).wakeHint(signal);
+            return { residency: r.residency, wake: null };
+        }
+        catch (err) {
+            if (!notRunning(err) || signal?.aborted)
+                throw err;
+            if (opts.wake === null)
+                return { residency: null, wake: null };
+            if (!this.#hintWake) {
+                const timeoutMs = opts.wakeTimeoutMs ?? DEFAULT_TRANSITION_TIMEOUT_MS;
+                // The default wake brings back the token of the hinted client (its label and tools).
+                const started = opts.wake
+                    ? opts.wake(timeoutMs).then((r) => r !== false)
+                    : this.wake({ timeoutMs, ...(agentLabel !== undefined ? { agentLabel } : {}), ...(tools !== undefined ? { tools } : {}) });
+                const shared = started.finally(() => {
+                    if (this.#hintWake === shared)
+                        this.#hintWake = null;
+                });
+                shared.catch(() => undefined); // nobody has to await it: a failed wake is left to the next tool call
+                this.#hintWake = shared;
+            }
+            return { residency: null, wake: this.#hintWake };
+        }
+    }
     /** Tools granted by the most recent token (null before one was issued). */
     get grantedTools() {
         for (const m of this.#managers.values())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shardflux/sdk",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "type": "module",
   "description": "Shardflux TypeScript SDK: open persistent agent workspaces by key and give your agent workspace tools (exec, files, processes, PTY, git, browser).",
   "license": "Apache-2.0",
@@ -60,6 +60,7 @@
     "ajv": "8.20.0",
     "eslint": "10.11.0",
     "langchain": "1.5.14",
+    "openai": "7.23.0",
     "openapi-typescript": "7.13.0",
     "typescript": "5.9.3",
     "typescript-eslint": "8.70.1",