@smooai/smooth-operator-temporal 1.13.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Smoo AI, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# @smooai/smooth-operator-temporal
+
+Optional **Temporal-backed durable execution** for the TypeScript
+[`@smooai/smooth-operator-core`](../core) agent engine (ADR-030). The TypeScript
+sibling of the Rust [`smooth-operator-temporal`](../../rust/smooth-operator-temporal)
+crate.
+
+An agent turn runs as a Temporal **workflow** whose side-effects — the model call
+and each tool invocation — are Temporal **activities**. The workflow drives the
+engine's deterministic `driveTurn` orchestration **unchanged**, so the durable
+path and the in-process path are the *same loop*. What durability buys: crash-safe
+resume, durable human-in-the-loop via signals, and durable timers (an agent that
+pauses itself for minutes or days and resumes).
+
+## Why a separate package
+
+Mirrors the Rust crate's off-by-default `temporal` cargo feature: the published
+`@smooai/smooth-operator-core` stays **zero-infra** and never pulls a Temporal SDK
+into a consumer's dependency tree. Only a deployment that wants durable execution
+installs this package. The activity **DTO boundary** (`./dto`) carries no Temporal
+dependency and is always unit-tested.
+
+## Shape
+
+| Export                    | Side     | Role                                                                    |
+| ------------------------- | -------- | ---------------------------------------------------------------------- |
+| `TemporalAgentExecutor`   | client   | The durable `AgentExecutor`; a drop-in for the engine's `InProcessExecutor`. |
+| `createActivities(h)`     | worker   | Build the worker's activity object from engine handles (model + tools). |
+| `agentTurnWorkflow`       | workflow | The turn workflow (registered via the `./workflows` subpath).           |
+| `approveToolSignal` / `denyToolSignal` | both | Durable HITL signals.                                        |
+
+## Testing
+
+```sh
+# Zero-infra DTO boundary unit test (always runs, no Temporal):
+pnpm --filter @smooai/smooth-operator-temporal test
+
+# Full e2e against an ephemeral Temporal dev server (health, agent turn,
+# durable timer, HITL) — self-skips offline:
+pnpm --filter @smooai/smooth-operator-core build
+pnpm --filter @smooai/smooth-operator-temporal build
+SMOOTH_TEMPORAL_E2E=1 pnpm --filter @smooai/smooth-operator-temporal test
+```

package/dist/activities.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The Temporal **activities** for the agent-turn workflow: the side-effecting
+ * half of a turn (the model call, each tool invocation) plus a liveness probe.
+ *
+ * The TS sibling of the Rust crate's `AgentTurnActivities`. Where the Rust
+ * activities read their engine handles from a process-global installed by
+ * `init_engine`, the TypeScript Temporal SDK registers activities as an object
+ * passed to `Worker.create({ activities })` — so the handles are simply closed
+ * over here via {@link createActivities}, no global needed.
+ *
+ * Each activity runs in the **normal Node context** (not the deterministic
+ * workflow sandbox), so it may import the full engine freely: the model call and
+ * tool dispatch are a verbatim reuse of the engine's own
+ * {@link InProcessActivities} — the same code the in-process executor runs — with
+ * the DTO projection applied on the way out. One implementation, two backends.
+ */
+import type { LlmProvider, Tool, ToolResult } from '@smooai/smooth-operator-core';
+import { type ModelCallInput, type ModelCallOutput, type ToolInvokeInput } from './dto.js';
+/**
+ * The engine handles the activities run against — the durable-path analog of the
+ * arguments the in-process executor is constructed with.
+ */
+export interface EngineHandles {
+    /** The OpenAI-compatible chat client backing the `modelCall` activity. */
+    llm: LlmProvider;
+    /** The tools dispatchable by the `toolInvoke` activity (default none). */
+    tools?: Tool[];
+    /** Model id for the request body; defaults to the engine's own default. */
+    model?: string;
+}
+/** The activity surface registered with a Temporal worker. */
+export interface AgentTurnActivities {
+    /** Liveness probe backing the scaffold health workflow. */
+    healthEcho(message: string): Promise<string>;
+    /** The model call (`Think`), run as a durable, retried activity. */
+    modelCall(input: ModelCallInput): Promise<ModelCallOutput>;
+    /** A single tool invocation (`Act`), run as a durable activity. */
+    toolInvoke(input: ToolInvokeInput): Promise<ToolResult>;
+}
+/**
+ * Build the activity object a Temporal worker registers, bound to `handles`.
+ *
+ * Tool *business* failures come back inside {@link ToolResult.isError} (not as a
+ * thrown activity error), exactly as {@link InProcessActivities.toolInvoke}
+ * reports them — matching the engine's own dispatch so the model reacts to a
+ * failed tool instead of the turn failing.
+ */
+export declare function createActivities(handles: EngineHandles): AgentTurnActivities;
+//# sourceMappingURL=activities.d.ts.map

package/dist/activities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activities.d.ts","sourceRoot":"","sources":["../src/activities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAElF,OAAO,EAAyB,KAAK,cAAc,EAAE,KAAK,eAAe,EAAE,KAAK,eAAe,EAAE,MAAM,UAAU,CAAC;AAElH;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC1B,0EAA0E;IAC1E,GAAG,EAAE,WAAW,CAAC;IACjB,0EAA0E;IAC1E,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;IACf,2EAA2E;IAC3E,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,8DAA8D;AAC9D,MAAM,WAAW,mBAAmB;IAChC,2DAA2D;IAC3D,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7C,oEAAoE;IACpE,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IAC3D,mEAAmE;IACnE,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CAC3D;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,aAAa,GAAG,mBAAmB,CAc5E"}

package/dist/activities.js

@@ -0,0 +1,42 @@
+/**
+ * The Temporal **activities** for the agent-turn workflow: the side-effecting
+ * half of a turn (the model call, each tool invocation) plus a liveness probe.
+ *
+ * The TS sibling of the Rust crate's `AgentTurnActivities`. Where the Rust
+ * activities read their engine handles from a process-global installed by
+ * `init_engine`, the TypeScript Temporal SDK registers activities as an object
+ * passed to `Worker.create({ activities })` — so the handles are simply closed
+ * over here via {@link createActivities}, no global needed.
+ *
+ * Each activity runs in the **normal Node context** (not the deterministic
+ * workflow sandbox), so it may import the full engine freely: the model call and
+ * tool dispatch are a verbatim reuse of the engine's own
+ * {@link InProcessActivities} — the same code the in-process executor runs — with
+ * the DTO projection applied on the way out. One implementation, two backends.
+ */
+import { InProcessActivities } from '@smooai/smooth-operator-core/executor';
+import { modelResponseToOutput } from './dto.js';
+/**
+ * Build the activity object a Temporal worker registers, bound to `handles`.
+ *
+ * Tool *business* failures come back inside {@link ToolResult.isError} (not as a
+ * thrown activity error), exactly as {@link InProcessActivities.toolInvoke}
+ * reports them — matching the engine's own dispatch so the model reacts to a
+ * failed tool instead of the turn failing.
+ */
+export function createActivities(handles) {
+    const inproc = new InProcessActivities(handles.llm, handles.tools ?? [], handles.model);
+    return {
+        async healthEcho(message) {
+            return `smooth-operator-temporal ok: ${message}`;
+        },
+        async modelCall(input) {
+            const response = await inproc.modelCall(input.messages, input.tools);
+            return modelResponseToOutput(response);
+        },
+        async toolInvoke(input) {
+            return inproc.toolInvoke(input.call);
+        },
+    };
+}
+//# sourceMappingURL=activities.js.map

package/dist/activities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"activities.js","sourceRoot":"","sources":["../src/activities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,uCAAuC,CAAC;AAG5E,OAAO,EAAE,qBAAqB,EAAmE,MAAM,UAAU,CAAC;AAyBlH;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAAsB;IACnD,MAAM,MAAM,GAAG,IAAI,mBAAmB,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,KAAK,IAAI,EAAE,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IACxF,OAAO;QACH,KAAK,CAAC,UAAU,CAAC,OAAe;YAC5B,OAAO,gCAAgC,OAAO,EAAE,CAAC;QACrD,CAAC;QACD,KAAK,CAAC,SAAS,CAAC,KAAqB;YACjC,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;YACrE,OAAO,qBAAqB,CAAC,QAAQ,CAAC,CAAC;QAC3C,CAAC;QACD,KAAK,CAAC,UAAU,CAAC,KAAsB;YACnC,OAAO,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACzC,CAAC;KACJ,CAAC;AACN,CAAC"}

package/dist/dto.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Data-transfer objects for the Temporal **activity boundary**.
+ *
+ * The TypeScript port of the Rust crate's `dto.rs`. A Temporal activity
+ * serializes its input and output as JSON, so the workflow-side
+ * {@link import('@smooai/smooth-operator-core').AgentActivities} surface cannot
+ * traffic the raw {@link ModelResponse} (the full OpenAI object) across the
+ * boundary directly — it traffics {@link ModelCallOutput}, a projection of the
+ * fields the deterministic `driveTurn` orchestration actually reads (`content`,
+ * `tool_calls`) plus the accounting fields (`usage`), and the workflow-side
+ * adapter reconstructs a minimal {@link ModelResponse} from it via
+ * {@link outputToModelResponse}.
+ *
+ * Everything here is plain data over `@smooai/smooth-operator-core` types and
+ * imports **no** `@temporalio/*` package, so it is always built and unit-tested
+ * regardless of whether a Temporal runtime is present — exactly like the Rust
+ * `dto.rs` compiling without the `temporal` cargo feature.
+ */
+import type { ModelResponse } from '@smooai/smooth-operator-core/executor';
+import type { ToolCall } from '@smooai/smooth-operator-core';
+/** Token usage carried across the activity boundary (OpenAI wire spelling). */
+export interface DtoUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+}
+/** Input to the `modelCall` activity: the context window + the tool specs to offer. */
+export interface ModelCallInput {
+    /** The conversation context window, as OpenAI-shaped messages. */
+    messages: Array<Record<string, unknown>>;
+    /** Tool schemas (the OpenAI `tools` array) the model may call; empty means none. */
+    tools: Array<Record<string, unknown>>;
+}
+/**
+ * Output of the `modelCall` activity: a serde projection of {@link ModelResponse}.
+ *
+ * Carries the fields the orchestration reads (`content`, `toolCalls`) plus the
+ * accounting `usage` so the durable path preserves cost/audit data. Anything the
+ * live OpenAI response carries beyond these is transient and dropped — it does
+ * not survive (nor need to survive) the activity boundary.
+ */
+export interface ModelCallOutput {
+    /** Assistant text content ('' when the model only asked for tools). */
+    content: string;
+    /** Tool calls the model requested, in OpenAI wire shape. */
+    toolCalls: Array<{
+        id: string;
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    /** Token usage reported by the gateway, if any. */
+    usage?: DtoUsage;
+}
+/** Input to the `toolInvoke` activity: the single tool call to execute. */
+export interface ToolInvokeInput {
+    /** The tool call (id + name + arguments) to dispatch. */
+    call: ToolCall;
+}
+/**
+ * Input to the agent-turn workflow — everything needed to seed the conversation
+ * and bound the loop. Serializable so it crosses the workflow-start boundary. The
+ * TS sibling of Rust's `AgentTurnInput`.
+ */
+export interface AgentTurnInput {
+    /** System prompt for the turn. */
+    systemPrompt: string;
+    /** The user message that opens the turn. */
+    userMessage: string;
+    /** Prior OpenAI-shaped messages replayed as memory before the user message. */
+    history?: Array<Record<string, unknown>>;
+    /** Tool schemas (the OpenAI `tools` array) available to the model. */
+    tools?: Array<Record<string, unknown>>;
+    /** Iteration bound. Omitted / `0` falls back to the loop's default. */
+    maxIterations?: number;
+    /**
+     * Names of tools that require human approval before they run. When the model
+     * calls one, the workflow blocks durably until an `approveTool` / `denyTool`
+     * signal names that tool call.
+     */
+    approvalRequiredTools?: string[];
+    /**
+     * Name of the built-in **durable wait** tool, if any. A model call to this tool
+     * with an integer `seconds` argument sleeps the workflow on a Temporal timer
+     * (a durable pause that can span days) instead of dispatching an activity.
+     */
+    waitTool?: string;
+}
+/**
+ * Result of the agent-turn workflow: the full conversation plus the turn
+ * accounting the durable path preserved. Serializable (it is the workflow's
+ * return value).
+ */
+export interface AgentTurnResult {
+    /** The full conversation (system + user + assistant/tool messages). */
+    messages: Array<Record<string, unknown>>;
+    /** Number of model-call iterations the loop ran. */
+    iterations: number;
+    /** Number of tools actually invoked (approval-denied / wait tools excluded). */
+    toolCalls: number;
+    /** Accumulated token usage across every model call. */
+    usage: DtoUsage;
+}
+/**
+ * Project a live {@link ModelResponse} down to the serde {@link ModelCallOutput}
+ * the activity returns. The TS sibling of Rust's `impl From<&LlmResponse> for
+ * ModelCallOutput`.
+ */
+export declare function modelResponseToOutput(response: ModelResponse): ModelCallOutput;
+/**
+ * Reconstruct the minimal {@link ModelResponse} the deterministic `driveTurn`
+ * loop consumes (`choices[0].message.{content,tool_calls}` + `usage`) from the
+ * activity's {@link ModelCallOutput}. The TS sibling of Rust's
+ * `ModelCallOutput::into_llm_response`.
+ */
+export declare function outputToModelResponse(output: ModelCallOutput): ModelResponse;
+//# sourceMappingURL=dto.d.ts.map

package/dist/dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dto.d.ts","sourceRoot":"","sources":["../src/dto.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AAC3E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAE7D,+EAA+E;AAC/E,MAAM,WAAW,QAAQ;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;CAC7B;AAED,uFAAuF;AACvF,MAAM,WAAW,cAAc;IAC3B,kEAAkE;IAClE,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACzC,oFAAoF;IACpF,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACzC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC5B,uEAAuE;IACvE,OAAO,EAAE,MAAM,CAAC;IAChB,4DAA4D;IAC5D,SAAS,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC,CAAC;IAChF,mDAAmD;IACnD,KAAK,CAAC,EAAE,QAAQ,CAAC;CACpB;AAED,2EAA2E;AAC3E,MAAM,WAAW,eAAe;IAC5B,yDAAyD;IACzD,IAAI,EAAE,QAAQ,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC3B,kCAAkC;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,4CAA4C;IAC5C,WAAW,EAAE,MAAM,CAAC;IACpB,+EAA+E;IAC/E,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACzC,sEAAsE;IACtE,KAAK,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACvC,uEAAuE;IACvE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;IACjC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC5B,uEAAuE;IACvE,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACzC,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB,gFAAgF;IAChF,SAAS,EAAE,MAAM,CAAC;IAClB,uDAAuD;IACvD,KAAK,EAAE,QAAQ,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,aAAa,GAAG,eAAe,CAiB9E;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,eAAe,GAAG,aAAa,CAY5E"}

package/dist/dto.js

@@ -0,0 +1,61 @@
+/**
+ * Data-transfer objects for the Temporal **activity boundary**.
+ *
+ * The TypeScript port of the Rust crate's `dto.rs`. A Temporal activity
+ * serializes its input and output as JSON, so the workflow-side
+ * {@link import('@smooai/smooth-operator-core').AgentActivities} surface cannot
+ * traffic the raw {@link ModelResponse} (the full OpenAI object) across the
+ * boundary directly — it traffics {@link ModelCallOutput}, a projection of the
+ * fields the deterministic `driveTurn` orchestration actually reads (`content`,
+ * `tool_calls`) plus the accounting fields (`usage`), and the workflow-side
+ * adapter reconstructs a minimal {@link ModelResponse} from it via
+ * {@link outputToModelResponse}.
+ *
+ * Everything here is plain data over `@smooai/smooth-operator-core` types and
+ * imports **no** `@temporalio/*` package, so it is always built and unit-tested
+ * regardless of whether a Temporal runtime is present — exactly like the Rust
+ * `dto.rs` compiling without the `temporal` cargo feature.
+ */
+/**
+ * Project a live {@link ModelResponse} down to the serde {@link ModelCallOutput}
+ * the activity returns. The TS sibling of Rust's `impl From<&LlmResponse> for
+ * ModelCallOutput`.
+ */
+export function modelResponseToOutput(response) {
+    const message = response.choices[0].message;
+    const usage = response.usage ?? undefined;
+    const out = {
+        content: message.content ?? '',
+        toolCalls: (message.tool_calls ?? []).map((tc) => ({
+            id: tc.id,
+            function: { name: tc.function.name, arguments: tc.function.arguments },
+        })),
+    };
+    if (usage) {
+        out.usage = {
+            prompt_tokens: usage.prompt_tokens ?? 0,
+            completion_tokens: usage.completion_tokens ?? 0,
+        };
+    }
+    return out;
+}
+/**
+ * Reconstruct the minimal {@link ModelResponse} the deterministic `driveTurn`
+ * loop consumes (`choices[0].message.{content,tool_calls}` + `usage`) from the
+ * activity's {@link ModelCallOutput}. The TS sibling of Rust's
+ * `ModelCallOutput::into_llm_response`.
+ */
+export function outputToModelResponse(output) {
+    return {
+        choices: [
+            {
+                message: {
+                    content: output.content,
+                    tool_calls: output.toolCalls.length > 0 ? output.toolCalls : null,
+                },
+            },
+        ],
+        usage: output.usage ?? null,
+    };
+}
+//# sourceMappingURL=dto.js.map

package/dist/dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dto.js","sourceRoot":"","sources":["../src/dto.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAwFH;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,QAAuB;IACzD,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;IAC5C,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,IAAI,SAAS,CAAC;IAC1C,MAAM,GAAG,GAAoB;QACzB,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,EAAE;QAC9B,SAAS,EAAE,CAAC,OAAO,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YAC/C,EAAE,EAAE,EAAE,CAAC,EAAE;YACT,QAAQ,EAAE,EAAE,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,CAAC,QAAQ,CAAC,SAAS,EAAE;SACzE,CAAC,CAAC;KACN,CAAC;IACF,IAAI,KAAK,EAAE,CAAC;QACR,GAAG,CAAC,KAAK,GAAG;YACR,aAAa,EAAE,KAAK,CAAC,aAAa,IAAI,CAAC;YACvC,iBAAiB,EAAE,KAAK,CAAC,iBAAiB,IAAI,CAAC;SAClD,CAAC;IACN,CAAC;IACD,OAAO,GAAG,CAAC;AACf,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,MAAuB;IACzD,OAAO;QACH,OAAO,EAAE;YACL;gBACI,OAAO,EAAE;oBACL,OAAO,EAAE,MAAM,CAAC,OAAO;oBACvB,UAAU,EAAE,MAAM,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI;iBACpE;aACJ;SACJ;QACD,KAAK,EAAE,MAAM,CAAC,KAAK,IAAI,IAAI;KACb,CAAC;AACvB,CAAC"}

package/dist/executor.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The Temporal-backed {@link AgentExecutor} — the durable sibling of the engine's
+ * zero-infra `InProcessExecutor`.
+ *
+ * It runs a turn by starting the {@link agentTurnWorkflow} on a Temporal cluster
+ * and awaiting its result, then shaping the returned conversation into the same
+ * {@link AgentRunResponse} `SmoothAgent.run` would produce. A consumer swaps a
+ * direct `agent.run(...)` for `executor.execute(agent, ...)` with no other change
+ * — the turn now survives a crash, gets durable HITL via signals, and can pause
+ * on a durable timer.
+ *
+ * ## The engine-handle split (mirrors Rust's `init_engine`)
+ *
+ * A durable turn has two halves in two processes: the **worker** holds the model
+ * client + tool *implementations* (via {@link createActivities}); this **executor**
+ * (client side) holds the turn *configuration* — system prompt, tool *schemas*,
+ * approval/wait policy — supplied at construction. That is why {@link execute}
+ * reads its prompt/tools from {@link TemporalAgentExecutorOptions} rather than off
+ * the passed `agent` (whose config is private and lives in the worker process).
+ * `message` and `history` ARE honored per call.
+ *
+ * The workflow is started by its **type name** (never by importing the workflow
+ * module), so this client-side file pulls in no `@temporalio/workflow` sandbox
+ * code — importing that module in a normal Node context throws.
+ */
+import type { Client } from '@temporalio/client';
+import type { AgentExecutor, AgentRunResponse, SmoothAgent, StreamEvent } from '@smooai/smooth-operator-core';
+import type { SmoothAgentThread } from '@smooai/smooth-operator-core';
+/** The Temporal workflow type name the worker registers {@link agentTurnWorkflow} under. */
+export declare const AGENT_TURN_WORKFLOW_TYPE = "agentTurnWorkflow";
+/** Configuration for a {@link TemporalAgentExecutor}. */
+export interface TemporalAgentExecutorOptions {
+    /** A connected `@temporalio/client` {@link Client}. */
+    client: Client;
+    /** The task queue the worker polls (must match the worker's). */
+    taskQueue: string;
+    /** System prompt for every turn this executor runs. */
+    systemPrompt?: string;
+    /** OpenAI tool schemas (the `tools` array) offered to the model. */
+    tools?: Array<Record<string, unknown>>;
+    /** Iteration bound; omitted / `0` uses the engine default. */
+    maxIterations?: number;
+    /** Tool names gated behind durable human approval (`approveTool` / `denyTool` signals). */
+    approvalRequiredTools?: string[];
+    /** Name of the durable wait tool, if any. */
+    waitTool?: string;
+    /** Prefix for generated workflow ids (default `agent-turn`). */
+    workflowIdPrefix?: string;
+}
+export declare class TemporalAgentExecutor implements AgentExecutor {
+    private readonly options;
+    constructor(options: TemporalAgentExecutorOptions);
+    execute(_agent: SmoothAgent, message: string, history?: Array<Record<string, unknown>>, _thread?: SmoothAgentThread): Promise<AgentRunResponse>;
+    /**
+     * A workflow-backed turn has no token-delta stream (its history is the
+     * checkpoint, not a live channel), so streaming resolves the durable turn and
+     * yields a single terminal `done`.
+     *
+     * ponytail: no incremental `text` / `tool_call` events on the durable path —
+     * a durable turn's progress is observed via workflow history/queries, not a
+     * token stream. Upgrade path (per ADR-030's open questions): a workflow-side
+     * signal/update channel feeding deltas back to the client.
+     */
+    executeStreaming(agent: SmoothAgent, message: string, history?: Array<Record<string, unknown>>, thread?: SmoothAgentThread): AsyncGenerator<StreamEvent>;
+}
+//# sourceMappingURL=executor.d.ts.map

package/dist/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../src/executor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC9G,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAItE,4FAA4F;AAC5F,eAAO,MAAM,wBAAwB,sBAAsB,CAAC;AAE5D,yDAAyD;AACzD,MAAM,WAAW,4BAA4B;IACzC,uDAAuD;IACvD,MAAM,EAAE,MAAM,CAAC;IACf,iEAAiE;IACjE,SAAS,EAAE,MAAM,CAAC;IAClB,uDAAuD;IACvD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oEAAoE;IACpE,KAAK,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACvC,8DAA8D;IAC9D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,2FAA2F;IAC3F,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;IACjC,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gEAAgE;IAChE,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,qBAAa,qBAAsB,YAAW,aAAa;IAC3C,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,4BAA4B;IAE5D,OAAO,CACT,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,CAAC,EAAE,iBAAiB,GAC5B,OAAO,CAAC,gBAAgB,CAAC;IAmB5B;;;;;;;;;OASG;IACI,gBAAgB,CACnB,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,MAAM,CAAC,EAAE,iBAAiB,GAC3B,cAAc,CAAC,WAAW,CAAC;CAIjC"}

package/dist/executor.js

@@ -0,0 +1,89 @@
+/**
+ * The Temporal-backed {@link AgentExecutor} — the durable sibling of the engine's
+ * zero-infra `InProcessExecutor`.
+ *
+ * It runs a turn by starting the {@link agentTurnWorkflow} on a Temporal cluster
+ * and awaiting its result, then shaping the returned conversation into the same
+ * {@link AgentRunResponse} `SmoothAgent.run` would produce. A consumer swaps a
+ * direct `agent.run(...)` for `executor.execute(agent, ...)` with no other change
+ * — the turn now survives a crash, gets durable HITL via signals, and can pause
+ * on a durable timer.
+ *
+ * ## The engine-handle split (mirrors Rust's `init_engine`)
+ *
+ * A durable turn has two halves in two processes: the **worker** holds the model
+ * client + tool *implementations* (via {@link createActivities}); this **executor**
+ * (client side) holds the turn *configuration* — system prompt, tool *schemas*,
+ * approval/wait policy — supplied at construction. That is why {@link execute}
+ * reads its prompt/tools from {@link TemporalAgentExecutorOptions} rather than off
+ * the passed `agent` (whose config is private and lives in the worker process).
+ * `message` and `history` ARE honored per call.
+ *
+ * The workflow is started by its **type name** (never by importing the workflow
+ * module), so this client-side file pulls in no `@temporalio/workflow` sandbox
+ * code — importing that module in a normal Node context throws.
+ */
+import { randomUUID } from 'node:crypto';
+/** The Temporal workflow type name the worker registers {@link agentTurnWorkflow} under. */
+export const AGENT_TURN_WORKFLOW_TYPE = 'agentTurnWorkflow';
+export class TemporalAgentExecutor {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async execute(_agent, message, history, _thread) {
+        const input = {
+            systemPrompt: this.options.systemPrompt ?? '',
+            userMessage: message,
+            history,
+            tools: this.options.tools,
+            maxIterations: this.options.maxIterations,
+            approvalRequiredTools: this.options.approvalRequiredTools,
+            waitTool: this.options.waitTool,
+        };
+        const workflowId = `${this.options.workflowIdPrefix ?? 'agent-turn'}-${randomUUID()}`;
+        const result = await this.options.client.workflow.execute(AGENT_TURN_WORKFLOW_TYPE, {
+            taskQueue: this.options.taskQueue,
+            workflowId,
+            args: [input],
+        });
+        return toAgentRunResponse(result);
+    }
+    /**
+     * A workflow-backed turn has no token-delta stream (its history is the
+     * checkpoint, not a live channel), so streaming resolves the durable turn and
+     * yields a single terminal `done`.
+     *
+     * ponytail: no incremental `text` / `tool_call` events on the durable path —
+     * a durable turn's progress is observed via workflow history/queries, not a
+     * token stream. Upgrade path (per ADR-030's open questions): a workflow-side
+     * signal/update channel feeding deltas back to the client.
+     */
+    async *executeStreaming(agent, message, history, thread) {
+        const response = await this.execute(agent, message, history, thread);
+        yield { type: 'done', response };
+    }
+}
+/** Shape a durable-turn {@link AgentTurnResult} into an engine {@link AgentRunResponse}. */
+function toAgentRunResponse(result) {
+    let text = '';
+    for (let i = result.messages.length - 1; i >= 0; i--) {
+        const msg = result.messages[i];
+        if (msg.role === 'assistant' && typeof msg.content === 'string' && msg.content.length > 0) {
+            text = msg.content;
+            break;
+        }
+    }
+    return {
+        text,
+        iterations: result.iterations,
+        toolCalls: result.toolCalls,
+        usage: { promptTokens: result.usage.prompt_tokens, completionTokens: result.usage.completion_tokens },
+        // ponytail: authoritative per-request cost lives in the gateway's spend
+        // logs, not carried back through the workflow boundary. Wire it via the
+        // model_call DTO's gateway cost when durable-turn cost attribution lands.
+        costUsd: 0,
+        budgetExceeded: false,
+    };
+}
+//# sourceMappingURL=executor.js.map

package/dist/executor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.js","sourceRoot":"","sources":["../src/executor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AASzC,4FAA4F;AAC5F,MAAM,CAAC,MAAM,wBAAwB,GAAG,mBAAmB,CAAC;AAsB5D,MAAM,OAAO,qBAAqB;IACD;IAA7B,YAA6B,OAAqC;QAArC,YAAO,GAAP,OAAO,CAA8B;IAAG,CAAC;IAEtE,KAAK,CAAC,OAAO,CACT,MAAmB,EACnB,OAAe,EACf,OAAwC,EACxC,OAA2B;QAE3B,MAAM,KAAK,GAAmB;YAC1B,YAAY,EAAE,IAAI,CAAC,OAAO,CAAC,YAAY,IAAI,EAAE;YAC7C,WAAW,EAAE,OAAO;YACpB,OAAO;YACP,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK;YACzB,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,aAAa;YACzC,qBAAqB,EAAE,IAAI,CAAC,OAAO,CAAC,qBAAqB;YACzD,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ;SAClC,CAAC;QACF,MAAM,UAAU,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,gBAAgB,IAAI,YAAY,IAAI,UAAU,EAAE,EAAE,CAAC;QACtF,MAAM,MAAM,GAAoB,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,wBAAwB,EAAE;YACjG,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS;YACjC,UAAU;YACV,IAAI,EAAE,CAAC,KAAK,CAAC;SAChB,CAAC,CAAC;QACH,OAAO,kBAAkB,CAAC,MAAM,CAAC,CAAC;IACtC,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,CAAC,gBAAgB,CACnB,KAAkB,EAClB,OAAe,EACf,OAAwC,EACxC,MAA0B;QAE1B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QACrE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;IACrC,CAAC;CACJ;AAED,4FAA4F;AAC5F,SAAS,kBAAkB,CAAC,MAAuB;IAC/C,IAAI,IAAI,GAAG,EAAE,CAAC;IACd,KAAK,IAAI,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QACnD,MAAM,GAAG,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QAC/B,IAAI,GAAG,CAAC,IAAI,KAAK,WAAW,IAAI,OAAO,GAAG,CAAC,OAAO,KAAK,QAAQ,IAAI,GAAG,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxF,IAAI,GAAG,GAAG,CAAC,OAAO,CAAC;YACnB,MAAM;QACV,CAAC;IACL,CAAC;IACD,OAAO;QACH,IAAI;QACJ,UAAU,EAAE,MAAM,CAAC,UAAU;QAC7B,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,KAAK,EAAE,EAAE,YAAY,EAAE,MAAM,CAAC,KAAK,CAAC,aAAa,EAAE,gBAAgB,EAAE,MAAM,CAAC,KAAK,CAAC,iBAAiB,EAAE;QACrG,wEAAwE;QACxE,wEAAwE;QACxE,0EAA0E;QAC1E,OAAO,EAAE,CAAC;QACV,cAAc,EAAE,KAAK;KACxB,CAAC;AACN,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @smooai/smooth-operator-temporal — optional Temporal-backed durable execution
+ * for the TypeScript smooth-operator engine (ADR-030).
+ *
+ * The TypeScript sibling of the Rust `smooth-operator-temporal` crate. An agent
+ * turn runs as a Temporal workflow ({@link agentTurnWorkflow}) whose model call
+ * and tool invocations are activities, driving the engine's deterministic
+ * `driveTurn` loop unchanged — the same loop the in-process executor runs.
+ *
+ * - {@link TemporalAgentExecutor} — the durable {@link AgentExecutor}; a
+ *   drop-in for the engine's `InProcessExecutor`.
+ * - {@link createActivities} — build the worker's activity object from engine
+ *   handles (model client + tools).
+ * - Workflows are also published at the `./workflows` subpath (the path a
+ *   Temporal worker registers) and activities at `./activities`.
+ * - The `./dto` boundary types (re-exported here) carry no Temporal dependency.
+ */
+export type { AgentTurnActivities, EngineHandles } from './activities.js';
+export { createActivities } from './activities.js';
+export type { AgentTurnInput, AgentTurnResult, DtoUsage, ModelCallInput, ModelCallOutput, ToolInvokeInput } from './dto.js';
+export { modelResponseToOutput, outputToModelResponse } from './dto.js';
+export { AGENT_TURN_WORKFLOW_TYPE, TemporalAgentExecutor } from './executor.js';
+export type { TemporalAgentExecutorOptions } from './executor.js';
+export { approveToolSignal, denyToolSignal } from './signals.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,YAAY,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,QAAQ,EAAE,cAAc,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC5H,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACxE,OAAO,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAChF,YAAY,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAC;AAKlE,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,26 @@
+/**
+ * @smooai/smooth-operator-temporal — optional Temporal-backed durable execution
+ * for the TypeScript smooth-operator engine (ADR-030).
+ *
+ * The TypeScript sibling of the Rust `smooth-operator-temporal` crate. An agent
+ * turn runs as a Temporal workflow ({@link agentTurnWorkflow}) whose model call
+ * and tool invocations are activities, driving the engine's deterministic
+ * `driveTurn` loop unchanged — the same loop the in-process executor runs.
+ *
+ * - {@link TemporalAgentExecutor} — the durable {@link AgentExecutor}; a
+ *   drop-in for the engine's `InProcessExecutor`.
+ * - {@link createActivities} — build the worker's activity object from engine
+ *   handles (model client + tools).
+ * - Workflows are also published at the `./workflows` subpath (the path a
+ *   Temporal worker registers) and activities at `./activities`.
+ * - The `./dto` boundary types (re-exported here) carry no Temporal dependency.
+ */
+export { createActivities } from './activities.js';
+export { modelResponseToOutput, outputToModelResponse } from './dto.js';
+export { AGENT_TURN_WORKFLOW_TYPE, TemporalAgentExecutor } from './executor.js';
+// Signals are exported from their own context-free module so a client can import
+// them; the workflow functions themselves live at the `./workflows` subpath (the
+// path a Temporal worker registers) and are NOT re-exported here — importing that
+// module in a normal Node process throws (its top-level `proxyActivities`).
+export { approveToolSignal, denyToolSignal } from './signals.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACxE,OAAO,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAEhF,iFAAiF;AACjF,iFAAiF;AACjF,kFAAkF;AAClF,4EAA4E;AAC5E,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC"}

package/dist/signals.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Signal definitions for the agent-turn workflow, in their own module so they are
+ * safe to import from BOTH sides: the workflow (which handles them) and a client
+ * (which sends them).
+ *
+ * {@link defineSignal} only builds a signal descriptor — it needs no workflow
+ * context — so importing this file in a normal Node/client process is safe, unlike
+ * importing `workflows.ts` (whose top-level `proxyActivities` throws outside a
+ * workflow).
+ */
+/** A human approves the tool call with this id, unblocking the durable HITL gate. */
+export declare const approveToolSignal: import("@temporalio/workflow").SignalDefinition<[string], string>;
+/** A human denies the tool call with this id; the gate skips it with an error result. */
+export declare const denyToolSignal: import("@temporalio/workflow").SignalDefinition<[string], string>;
+//# sourceMappingURL=signals.d.ts.map

package/dist/signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signals.d.ts","sourceRoot":"","sources":["../src/signals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,qFAAqF;AACrF,eAAO,MAAM,iBAAiB,mEAAwC,CAAC;AACvE,yFAAyF;AACzF,eAAO,MAAM,cAAc,mEAAqC,CAAC"}

package/dist/signals.js

@@ -0,0 +1,16 @@
+/**
+ * Signal definitions for the agent-turn workflow, in their own module so they are
+ * safe to import from BOTH sides: the workflow (which handles them) and a client
+ * (which sends them).
+ *
+ * {@link defineSignal} only builds a signal descriptor — it needs no workflow
+ * context — so importing this file in a normal Node/client process is safe, unlike
+ * importing `workflows.ts` (whose top-level `proxyActivities` throws outside a
+ * workflow).
+ */
+import { defineSignal } from '@temporalio/workflow';
+/** A human approves the tool call with this id, unblocking the durable HITL gate. */
+export const approveToolSignal = defineSignal('approveTool');
+/** A human denies the tool call with this id; the gate skips it with an error result. */
+export const denyToolSignal = defineSignal('denyTool');
+//# sourceMappingURL=signals.js.map

package/dist/signals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signals.js","sourceRoot":"","sources":["../src/signals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,qFAAqF;AACrF,MAAM,CAAC,MAAM,iBAAiB,GAAG,YAAY,CAAW,aAAa,CAAC,CAAC;AACvE,yFAAyF;AACzF,MAAM,CAAC,MAAM,cAAc,GAAG,YAAY,CAAW,UAAU,CAAC,CAAC"}

package/dist/workflows.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The Temporal **workflows** (the deterministic half of durable execution).
+ *
+ * The TS sibling of the Rust crate's `AgentTurnWorkflow` + `HealthWorkflow`. An
+ * agent turn runs as {@link agentTurnWorkflow}, which drives the engine's
+ * deterministic {@link driveTurn} orchestration **unchanged** over an adapter
+ * that schedules the model call and each tool invocation as Temporal activities.
+ * The in-process executor runs the same `driveTurn` inline — one loop, two
+ * backends.
+ *
+ * This module runs in Temporal's **deterministic workflow sandbox**, so it may
+ * import only replay-safe code: `@temporalio/workflow` primitives, the pure
+ * `driveTurn` + its types from `@smooai/smooth-operator-core/executor` (that
+ * entry point has zero runtime imports — it is type-only), and the plain DTO
+ * helpers. It performs no I/O, clock reads, or RNG of its own — every
+ * side-effect is a scheduled activity, every wait a durable `sleep`/`condition`.
+ */
+import { type AgentTurnInput, type AgentTurnResult } from './dto.js';
+/**
+ * Run one agent turn as a durable workflow. Seeds the conversation (system +
+ * history + user), then drives {@link driveTurn} over an activity-scheduling
+ * adapter, and returns the full conversation plus turn accounting.
+ *
+ * Durable human-in-the-loop and durable timers live in the adapter, not in
+ * `driveTurn`: an approval-gated tool blocks on {@link condition} until an
+ * `approveTool` / `denyTool` signal names its call id, and the configured wait
+ * tool sleeps on a durable {@link sleep} timer — both recorded in workflow
+ * history, so they survive worker restarts and can resolve arbitrarily later.
+ */
+export declare function agentTurnWorkflow(input: AgentTurnInput): Promise<AgentTurnResult>;
+/**
+ * Scaffold liveness workflow — proves the SDK integrates end to end and backs the
+ * health e2e. The TS sibling of the Rust crate's `HealthWorkflow`.
+ */
+export declare function healthWorkflow(message: string): Promise<string>;
+//# sourceMappingURL=workflows.d.ts.map

package/dist/workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflows.d.ts","sourceRoot":"","sources":["../src/workflows.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAUH,OAAO,EAAyB,KAAK,cAAc,EAAE,KAAK,eAAe,EAAE,MAAM,UAAU,CAAC;AAY5F;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC,CAmEvF;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAErE"}

package/dist/workflows.js

@@ -0,0 +1,112 @@
+/**
+ * The Temporal **workflows** (the deterministic half of durable execution).
+ *
+ * The TS sibling of the Rust crate's `AgentTurnWorkflow` + `HealthWorkflow`. An
+ * agent turn runs as {@link agentTurnWorkflow}, which drives the engine's
+ * deterministic {@link driveTurn} orchestration **unchanged** over an adapter
+ * that schedules the model call and each tool invocation as Temporal activities.
+ * The in-process executor runs the same `driveTurn` inline — one loop, two
+ * backends.
+ *
+ * This module runs in Temporal's **deterministic workflow sandbox**, so it may
+ * import only replay-safe code: `@temporalio/workflow` primitives, the pure
+ * `driveTurn` + its types from `@smooai/smooth-operator-core/executor` (that
+ * entry point has zero runtime imports — it is type-only), and the plain DTO
+ * helpers. It performs no I/O, clock reads, or RNG of its own — every
+ * side-effect is a scheduled activity, every wait a durable `sleep`/`condition`.
+ */
+import { condition, proxyActivities, setHandler, sleep } from '@temporalio/workflow';
+import { driveTurn } from '@smooai/smooth-operator-core/executor';
+import { outputToModelResponse } from './dto.js';
+import { approveToolSignal, denyToolSignal } from './signals.js';
+/**
+ * Activity stubs. 60s start-to-close mirrors the Rust crate's
+ * `agent_activity_opts`; the SDK's default retry policy makes transient model /
+ * tool failures durable retries rather than turn failures.
+ */
+const { modelCall, toolInvoke, healthEcho } = proxyActivities({
+    startToCloseTimeout: '60s',
+});
+/**
+ * Run one agent turn as a durable workflow. Seeds the conversation (system +
+ * history + user), then drives {@link driveTurn} over an activity-scheduling
+ * adapter, and returns the full conversation plus turn accounting.
+ *
+ * Durable human-in-the-loop and durable timers live in the adapter, not in
+ * `driveTurn`: an approval-gated tool blocks on {@link condition} until an
+ * `approveTool` / `denyTool` signal names its call id, and the configured wait
+ * tool sleeps on a durable {@link sleep} timer — both recorded in workflow
+ * history, so they survive worker restarts and can resolve arbitrarily later.
+ */
+export async function agentTurnWorkflow(input) {
+    const approved = new Set();
+    const denied = new Set();
+    setHandler(approveToolSignal, (callId) => {
+        approved.add(callId);
+    });
+    setHandler(denyToolSignal, (callId) => {
+        denied.add(callId);
+    });
+    const messages = [];
+    if (input.systemPrompt)
+        messages.push({ role: 'system', content: input.systemPrompt });
+    if (input.history)
+        messages.push(...input.history);
+    messages.push({ role: 'user', content: input.userMessage });
+    let iterations = 0;
+    let toolCalls = 0;
+    const usage = { prompt_tokens: 0, completion_tokens: 0 };
+    const approvalRequired = input.approvalRequiredTools ?? [];
+    const activities = {
+        async modelCall(msgs, tools) {
+            iterations += 1;
+            const output = await modelCall({ messages: msgs, tools });
+            if (output.usage) {
+                usage.prompt_tokens += output.usage.prompt_tokens;
+                usage.completion_tokens += output.usage.completion_tokens;
+            }
+            return outputToModelResponse(output);
+        },
+        async toolInvoke(call) {
+            // Durable wait: the configured wait tool sleeps on a Temporal timer
+            // instead of dispatching an activity. Recorded in history, so the
+            // pause survives restarts and can span days.
+            if (input.waitTool !== undefined && call.name === input.waitTool) {
+                const raw = call.arguments.seconds;
+                const seconds = typeof raw === 'number' ? raw : Number(raw);
+                if (!Number.isInteger(seconds) || seconds < 0) {
+                    return { toolCallId: call.id, content: `wait tool '${call.name}' requires an integer 'seconds' argument`, isError: true };
+                }
+                await sleep(seconds * 1000);
+                return { toolCallId: call.id, content: `Waited ${seconds}s (durable timer).`, isError: false };
+            }
+            // Durable human-in-the-loop gate: block until a signal names this call
+            // id. `driveTurn` is unchanged — the gate lives here.
+            if (approvalRequired.includes(call.name)) {
+                await condition(() => approved.has(call.id) || denied.has(call.id));
+                if (denied.has(call.id)) {
+                    return { toolCallId: call.id, content: `Tool call '${call.name}' was denied by human approval.`, isError: true };
+                }
+            }
+            toolCalls += 1;
+            return toolInvoke({ call });
+        },
+    };
+    if (input.maxIterations !== undefined && input.maxIterations > 0) {
+        await driveTurn(activities, messages, input.tools ?? [], { maxIterations: input.maxIterations });
+    }
+    else {
+        // Omit the policy so the engine's own default iteration bound applies —
+        // never a magic number duplicated here.
+        await driveTurn(activities, messages, input.tools ?? []);
+    }
+    return { messages, iterations, toolCalls, usage };
+}
+/**
+ * Scaffold liveness workflow — proves the SDK integrates end to end and backs the
+ * health e2e. The TS sibling of the Rust crate's `HealthWorkflow`.
+ */
+export async function healthWorkflow(message) {
+    return healthEcho(message);
+}
+//# sourceMappingURL=workflows.js.map

package/dist/workflows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflows.js","sourceRoot":"","sources":["../src/workflows.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAErF,OAAO,EAAE,SAAS,EAAE,MAAM,uCAAuC,CAAC;AAMlE,OAAO,EAAE,qBAAqB,EAA6C,MAAM,UAAU,CAAC;AAC5F,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEjE;;;;GAIG;AACH,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,eAAe,CAAsB;IAC/E,mBAAmB,EAAE,KAAK;CAC7B,CAAC,CAAC;AAEH;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,KAAqB;IACzD,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAC;IACnC,MAAM,MAAM,GAAG,IAAI,GAAG,EAAU,CAAC;IACjC,UAAU,CAAC,iBAAiB,EAAE,CAAC,MAAc,EAAE,EAAE;QAC7C,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,CAAC,CAAC,CAAC;IACH,UAAU,CAAC,cAAc,EAAE,CAAC,MAAc,EAAE,EAAE;QAC1C,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IACvB,CAAC,CAAC,CAAC;IAEH,MAAM,QAAQ,GAAmC,EAAE,CAAC;IACpD,IAAI,KAAK,CAAC,YAAY;QAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC;IACvF,IAAI,KAAK,CAAC,OAAO;QAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;IACnD,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC;IAE5D,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,MAAM,KAAK,GAAG,EAAE,aAAa,EAAE,CAAC,EAAE,iBAAiB,EAAE,CAAC,EAAE,CAAC;IACzD,MAAM,gBAAgB,GAAG,KAAK,CAAC,qBAAqB,IAAI,EAAE,CAAC;IAE3D,MAAM,UAAU,GAAoB;QAChC,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK;YACvB,UAAU,IAAI,CAAC,CAAC;YAChB,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;YAC1D,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;gBACf,KAAK,CAAC,aAAa,IAAI,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC;gBAClD,KAAK,CAAC,iBAAiB,IAAI,MAAM,CAAC,KAAK,CAAC,iBAAiB,CAAC;YAC9D,CAAC;YACD,OAAO,qBAAqB,CAAC,MAAM,CAAC,CAAC;QACzC,CAAC;QACD,KAAK,CAAC,UAAU,CAAC,IAAc;YAC3B,oEAAoE;YACpE,kEAAkE;YAClE,6CAA6C;YAC7C,IAAI,KAAK,CAAC,QAAQ,KAAK,SAAS,IAAI,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,QAAQ,EAAE,CAAC;gBAC/D,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;gBACnC,MAAM,OAAO,GAAG,OAAO,GAAG,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBAC5D,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;oBAC5C,OAAO,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,cAAc,IAAI,CAAC,IAAI,0CAA0C,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;gBAC9H,CAAC;gBACD,MAAM,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;gBAC5B,OAAO,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,UAAU,OAAO,oBAAoB,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;YACnG,CAAC;YAED,uEAAuE;YACvE,sDAAsD;YACtD,IAAI,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;gBACvC,MAAM,SAAS,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;gBACpE,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;oBACtB,OAAO,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,EAAE,OAAO,EAAE,cAAc,IAAI,CAAC,IAAI,iCAAiC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;gBACrH,CAAC;YACL,CAAC;YAED,SAAS,IAAI,CAAC,CAAC;YACf,OAAO,UAAU,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;QAChC,CAAC;KACJ,CAAC;IAEF,IAAI,KAAK,CAAC,aAAa,KAAK,SAAS,IAAI,KAAK,CAAC,aAAa,GAAG,CAAC,EAAE,CAAC;QAC/D,MAAM,SAAS,CAAC,UAAU,EAAE,QAAQ,EAAE,KAAK,CAAC,KAAK,IAAI,EAAE,EAAE,EAAE,aAAa,EAAE,KAAK,CAAC,aAAa,EAAE,CAAC,CAAC;IACrG,CAAC;SAAM,CAAC;QACJ,wEAAwE;QACxE,wCAAwC;QACxC,MAAM,SAAS,CAAC,UAAU,EAAE,QAAQ,EAAE,KAAK,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC;IAC7D,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;AACtD,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,OAAe;IAChD,OAAO,UAAU,CAAC,OAAO,CAAC,CAAC;AAC/B,CAAC"}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@smooai/smooth-operator-temporal",
+  "version": "1.13.5",
+  "description": "Optional Temporal-backed durable execution backend for the smooth-operator agent engine (ADR-030). The TypeScript sibling of the Rust `smooth-operator-temporal` crate — an agent turn runs as a Temporal workflow whose model call and tool invocations are activities, driving the same `driveTurn` loop as the in-process executor.",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SmooAI/smooth-operator-core.git",
+    "directory": "typescript/temporal"
+  },
+  "homepage": "https://github.com/SmooAI/smooth-operator-core/tree/main/typescript/temporal",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./workflows": {
+      "types": "./dist/workflows.d.ts",
+      "import": "./dist/workflows.js"
+    },
+    "./activities": {
+      "types": "./dist/activities.d.ts",
+      "import": "./dist/activities.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@temporalio/activity": "^1.11.0",
+    "@temporalio/client": "^1.11.0",
+    "@temporalio/worker": "^1.11.0",
+    "@temporalio/workflow": "^1.11.0",
+    "@smooai/smooth-operator-core": "1.13.5"
+  },
+  "devDependencies": {
+    "@temporalio/testing": "^1.11.0",
+    "@types/node": "^25.9.2",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.8"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
+}