@smooai/smooth-operator-core 0.1.0 → 0.9.0

package/README.md

@@ -0,0 +1,105 @@
+<p align="center">
+  <a href="https://smoo.ai"><img src="https://raw.githubusercontent.com/SmooAI/smooth-operator-core/main/.github/banner-typescript.png" alt="smooth-operator-core — The TypeScript engine for orchestrated AI agents" width="100%" /></a>
+</p>
+
+<p align="center">
+  <a href="https://smoo.ai/th"><img src="https://img.shields.io/badge/Smoo_AI-platform-00A6A6?style=for-the-badge&labelColor=020618" alt="Smoo AI"></a>
+  <a href="https://github.com/SmooAI/smooth-operator-core/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-F49F0A?style=for-the-badge&labelColor=020618" alt="license"></a>
+  <a href="https://lom.smoo.ai"><img src="https://img.shields.io/badge/hosted-lom.smoo.ai-FF6B6C?style=for-the-badge&labelColor=020618" alt="lom.smoo.ai"></a>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@smooai/smooth-operator-core"><img src="https://img.shields.io/npm/v/@smooai/smooth-operator-core?style=flat-square&color=00A6A6&labelColor=020618" alt="npm"></a>
+  <img src="https://img.shields.io/badge/TypeScript-engine-3178C6?style=flat-square&labelColor=020618" alt="TypeScript engine">
+</p>
+
+---
+
+> The TypeScript sibling of the [Rust reference engine](https://github.com/SmooAI/smooth-operator-core). Agents, tools, knowledge/RAG, memory, checkpointing, human-in-the-loop, cost budgets, and workflows — as one embeddable npm package. It's the engine, not a notebook demo.
+
+`@smooai/smooth-operator-core` is the **native TypeScript implementation** of the Smoo AI agent engine — the in-process observe→think→act loop that powers [**lom.smoo.ai**](https://lom.smoo.ai). It's a sibling of the [Rust reference engine](https://github.com/SmooAI/smooth-operator-core) and one of the [polyglot set](https://github.com/SmooAI/smooth-operator-core/blob/main/docs/Polyglot-Engines.md) (Rust, TypeScript, Python, Go, C#/.NET) whose behavior is held at parity by a shared eval suite.
+
+It's a library, not a client to a remote server: it *is* the agent, running in your Node process. Every surface is covered by **fast, offline tests** built on a deterministic `MockLlmProvider`, so the loop is verified — not vibe-coded.
+
+## Install
+
+```bash
+npm install @smooai/smooth-operator-core
+```
+
+## Quickstart
+
+A complete agent — no credentials needed — using the deterministic mock provider the engine's own tests run on:
+
+```ts
+import { SmoothAgent, MockLlmProvider } from '@smooai/smooth-operator-core';
+
+const provider = new MockLlmProvider().pushText('the answer is 42');
+const agent = new SmoothAgent(provider, { instructions: 'You are a helpful assistant' });
+
+const response = await agent.run('what is the answer?');
+console.log(response.text);
+```
+
+`SmoothAgent`'s constructor takes a `ChatClientLike` (the `MockLlmProvider` implements it — swap in any OpenAI-compatible client) and an `AgentOptions` object. `run` returns an `AgentRunResponse` whose `text` is the final answer.
+
+## Features
+
+The full parity surface — every engine in the [polyglot set](https://github.com/SmooAI/smooth-operator-core/blob/main/docs/Polyglot-Engines.md) ships it:
+
+- **Agentic tool-calling loop** — observe→think→act, looping until the model answers.
+- **Typed tools** — register `Tool`s the model can call, with parallel dispatch.
+- **Knowledge / RAG + vectors** — `InMemoryKnowledge` / `VectorKnowledge` ground the turn in retrieved documents.
+- **Memory** — `InMemoryMemory` recalls long-term entries into context each turn.
+- **Compaction** — a sliding-window token budget keeps the prompt under a ceiling.
+- **Cost / budget** — `CostTracker` + `CostBudget` with per-model pricing and early stop.
+- **Checkpointing** — `InMemoryCheckpointStore` (and the `CheckpointStore` seam) persist/resume a conversation.
+- **Rerank** — `LexicalReranker` reranks retrieved hits before injection.
+- **Sub-agents / delegation** — `delegateTool` spawns child agents for sub-tasks.
+- **Cast + clearance** — `Cast`, `Clearance`, `makeRole` for per-role tool-access policy.
+- **Human-in-the-loop gate** — `HumanGate` requires approval before designated tool calls run.
+- **Conversation thread** — `SmoothAgentThread` carries a conversation across multiple `run` calls.
+- **`LlmProvider` seam + `MockLlmProvider`** — inject any OpenAI-compatible client; the record/replay mock drives the offline tests.
+- **Deferred tools + `tool_search`** — `ToolSearch` hides rarely-used tool schemas behind a meta-tool the model calls to promote the ones it needs.
+- **Typed workflow graph** — `Workflow` with typed nodes/edges, alongside the agent loop.
+- **Parallel tool calls** — dispatch ≥2 tool calls concurrently (transcript order preserved).
+- **Retry / backoff** — retry transient model-call failures with exponential backoff.
+- **Streaming** — stream incremental text, tool calls, and tool results as the turn runs.
+
+## Streaming
+
+`runStream` is an async generator over a `StreamEvent` tagged union (discriminated on `type`): `text` deltas as the model produces them, each `tool_call` before dispatch, each `tool_result` after it finishes, and a terminal `done` event carrying the same response `run` would have returned.
+
+```ts
+for await (const event of agent.runStream('what is the answer?')) {
+    if (event.type === 'text') process.stdout.write(event.text);
+    if (event.type === 'done') console.log(`\n${event.response.text}`);
+}
+```
+
+`runStream` requires a streaming-capable client (`chat.completions.createStream`); the `MockLlmProvider` supplies one, replaying the same script as the non-streaming path.
+
+## Part of Smoo AI
+
+`smooth-operator-core` is built and open-sourced by **[Smoo AI](https://smoo.ai)** — the AI-powered business platform with AI built into every product: CRM, customer support, campaigns, field service, observability, and developer tools.
+
+- 🚀 **Smooth on the platform** — [smoo.ai/th](https://smoo.ai/th)
+- 🧰 **More open source from Smoo AI** — [smoo.ai/open-source](https://smoo.ai/open-source)
+- 🧩 **Run it hosted** — [lom.smoo.ai](https://lom.smoo.ai)
+
+## Links
+
+- [**lom.smoo.ai**](https://lom.smoo.ai) — run it hosted
+- [smooth-operator-core](https://github.com/SmooAI/smooth-operator-core) — the polyglot engine repo
+- [Polyglot Engines](https://github.com/SmooAI/smooth-operator-core/blob/main/docs/Polyglot-Engines.md) — install + hello-agent in all five languages
+- [smoo.ai](https://smoo.ai) — the product · [smoo.ai/open-source](https://smoo.ai/open-source) — more open source
+
+## License
+
+MIT — see [LICENSE](https://github.com/SmooAI/smooth-operator-core/blob/main/LICENSE).
+
+---
+
+<p align="center">
+  Built by <a href="https://smoo.ai"><strong>Smoo AI</strong></a> — AI built into every product.
+</p>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smooai/smooth-operator-core",
-  "version": "0.1.0",
+  "version": "0.9.0",
   "description": "Native TypeScript implementation of the smooth-operator agent engine — an in-process, OpenAI-compatible agentic tool-calling loop with knowledge grounding. The TypeScript sibling of the Rust reference engine, the C# core, and the Python core.",
   "type": "module",
   "license": "MIT",
@@ -17,13 +17,18 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./extension": {
+      "types": "./dist/extension/index.d.ts",
+      "import": "./dist/extension/index.js"
     }
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "openai": "^4.77.0"
+    "openai": "^4.77.0",
+    "smol-toml": "^1.7.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.2",

package/dist/agent.d.ts

@@ -1,276 +0,0 @@
-/**
- * The TypeScript smooth-operator core: a native agentic loop.
- *
- * Phase-0 sibling of the C# `SmoothAgent` (`dotnet/core`), the Python core
- * (`python/core`), and the Rust reference engine. Drives an agentic tool-calling
- * loop over any OpenAI-compatible chat client (the `openai` SDK pointed at a
- * gateway): inject retrieved knowledge, call the model, run any requested tools,
- * feed results back, and loop until the model answers without a tool call or the
- * iteration budget is hit.
- *
- * Deliberately minimal (no compaction / budget / checkpointing yet) — those layer
- * on exactly as they did when the C# core grew past Phase 0.
- */
-import type { Clearance } from './cast.js';
-import type { CheckpointStore } from './checkpoint.js';
-import type { SmoothAgentThread } from './thread.js';
-import type { Memory } from './memory.js';
-import type { Reranker } from './rerank.js';
-import type { CostBudget, ModelPricing, Usage } from './cost.js';
-import type { HumanGate } from './humanGate.js';
-import type { Knowledge } from './knowledge.js';
-/** A callable tool the agent may invoke. Mirrors the reference engines' tool seam. */
-export interface Tool {
-    name: string;
-    description: string;
-    /** JSON Schema for the tool's arguments. */
-    parameters: Record<string, unknown>;
-    execute(args: Record<string, unknown>): Promise<string>;
-}
-export interface AgentOptions {
-    instructions?: string;
-    model?: string;
-    maxIterations?: number;
-    maxTokens?: number;
-    temperature?: number;
-    knowledge?: Knowledge;
-    knowledgeTopK?: number;
-    /** Reranker applied to retrieved hits before injection (default: passthrough). */
-    reranker?: Reranker;
-    /** Candidate pool size to retrieve before reranking; when > knowledgeTopK, more docs are fetched, reranked, then trimmed. */
-    knowledgeCandidateK?: number;
-    /** Optional long-term memory; relevant entries are recalled into context each turn. */
-    memory?: Memory;
-    /** How many memory entries to recall per turn (default 4). */
-    memoryTopK?: number;
-    tools?: Tool[];
-    /**
-     * When `true` and an assistant turn returns ≥2 tool calls, dispatch them
-     * concurrently (`Promise.all`) instead of sequentially. The tool-result
-     * messages are still appended in the original `tool_calls` order, so the
-     * transcript stays deterministic regardless of completion order. Default
-     * `false` preserves the sequential behaviour. Per-tool semantics (clearance,
-     * human-gate approval, tool_search promotion, JSON parsing, error handling)
-     * are unchanged — only the dispatch loop runs in parallel.
-     */
-    parallelToolCalls?: boolean;
-    /**
-     * Deferred tools — registered but with their schemas HIDDEN from the model.
-     * When any are present, a built-in `tool_search` meta-tool is advertised in
-     * their place; the model calls it to fuzzy-match and promote the ones it needs,
-     * which then become visible + dispatchable on subsequent turns. Keeps the tool
-     * schema payload small when there are many rarely-used tools. An unpromoted
-     * deferred tool is NOT dispatchable.
-     */
-    deferredTools?: Tool[];
-    /**
-     * Approximate token budget for the context window. Before each model call,
-     * older non-system messages are dropped (sliding window) to stay under it.
-     * `0` disables compaction. Defaults to 8000.
-     */
-    maxContextTokens?: number;
-    /** Optional ceiling for the turn (token and/or USD). The turn stops early once a model call pushes usage/cost over the budget. */
-    budget?: CostBudget;
-    /** Per-model pricing override for cost accounting (defaults to DEFAULT_PRICING). */
-    pricing?: Record<string, ModelPricing>;
-    /** Optional store for persisting/resuming the conversation. Used with `conversationId`. */
-    checkpointStore?: CheckpointStore;
-    /** Conversation id for the checkpoint store (required to use checkpointing). */
-    conversationId?: string;
-    /**
-     * Optional tool-access policy. When set, a tool the clearance forbids is not
-     * dispatched — a "tool not permitted" result is returned to the model instead.
-     * Undefined allows every tool (the prior behaviour).
-     */
-    clearance?: Clearance;
-    /**
-     * Optional human-in-the-loop gate. When set, the agent asks it for approval before
-     * running any tool call for which {@link requiresApproval} returns true. A denied call
-     * is not executed; the model is told it was denied and can adapt.
-     */
-    humanGate?: HumanGate;
-    /**
-     * Which tool calls need human approval (e.g. writes / destructive actions), given the
-     * tool name and parsed arguments. Default: none. Only consulted when `humanGate` is set.
-     * Example: `requiresApproval: (name) => name === 'delete_record' || name === 'send_email'`.
-     */
-    requiresApproval?: (name: string, args: Record<string, unknown>) => boolean;
-    /**
-     * Number of ADDITIONAL attempts after the first if the model call throws a transient
-     * error (rate-limit, 5xx, dropped connection). `0` (the default) preserves today's
-     * behaviour: a single attempt, error propagates immediately. Only the model call is
-     * retried — never tool execution.
-     */
-    maxRetries?: number;
-    /**
-     * Base delay (milliseconds) for exponential backoff between retries. The wait before
-     * retry attempt `n` (1-indexed) is `retryBackoffMs * 2 ** (n - 1)`. Defaults to 200.
-     * Set to `0` to retry without sleeping (used by tests).
-     */
-    retryBackoffMs?: number;
-}
-export interface AgentRunResponse {
-    text: string;
-    iterations: number;
-    toolCalls: number;
-    usage: Usage;
-    costUsd: number;
-    /** True if the turn stopped because the cost/token budget was hit. */
-    budgetExceeded: boolean;
-}
-/**
- * One streamed chunk from a streaming chat completion — the standard OpenAI
- * `chat.completions` streaming chunk shape. `content` deltas concatenate into the
- * assistant text; `tool_calls` fragments are assembled by their `index` (the `id`
- * + `function.name` appear when the call first opens, `function.arguments` arrives
- * in fragments). `usage` is sent by gateways on (typically) the final chunk.
- */
-export interface ChatChunk {
-    choices: Array<{
-        delta: {
-            content?: string | null;
-            tool_calls?: Array<{
-                index: number;
-                id?: string;
-                function?: {
-                    name?: string;
-                    arguments?: string;
-                };
-            }> | null;
-        };
-    }>;
-    usage?: {
-        prompt_tokens?: number | null;
-        completion_tokens?: number | null;
-    } | null;
-}
-/**
- * The minimal shape of the OpenAI-compatible client the agent needs. The real
- * `openai` SDK's `OpenAI` satisfies this; tests inject a fake.
- *
- * `chat.completions.create` is the non-streaming call the {@link SmoothAgent.run}
- * loop uses. `createStream` is the optional streaming call the
- * {@link SmoothAgent.runStream} loop uses — production wires it to the real SDK's
- * `create({ ...body, stream: true })` (which returns an async-iterable of
- * {@link ChatChunk}s). It is optional so non-streaming consumers and the existing
- * fakes keep satisfying the interface; `runStream` throws if it is absent.
- */
-export interface ChatClientLike {
-    chat: {
-        completions: {
-            create(body: Record<string, unknown>): Promise<{
-                choices: Array<{
-                    message: {
-                        content: string | null;
-                        tool_calls?: Array<{
-                            id: string;
-                            function: {
-                                name: string;
-                                arguments: string;
-                            };
-                        }> | null;
-                    };
-                }>;
-                usage?: {
-                    prompt_tokens?: number | null;
-                    completion_tokens?: number | null;
-                } | null;
-            }>;
-            /**
-             * Streaming variant of {@link create}. Production wires this to the real
-             * `openai` SDK's `create({ ...body, stream: true })`, which returns an
-             * `AsyncIterable<ChatChunk>`. Optional so non-streaming clients still satisfy
-             * the seam; {@link SmoothAgent.runStream} requires it.
-             */
-            createStream?(body: Record<string, unknown>): AsyncIterable<ChatChunk>;
-        };
-    };
-}
-/**
- * A streamed event from {@link SmoothAgent.runStream}. A tagged union discriminated
- * on `type`, mirroring the C# `RunStreamingAsync` update sequence and the Rust
- * reference engine's event stream:
- *
- * - `text`     — an incremental assistant content delta as it streams in.
- * - `tool_call`— a tool call the model requested, emitted once (after the model
- *                stream for the iteration completes) before it is dispatched.
- * - `tool_result` — a tool's result, emitted after it finishes.
- * - `done`     — the single terminal event, carrying the same {@link AgentRunResponse}
- *                that {@link SmoothAgent.run} would return for the same script.
- */
-export type StreamEvent = {
-    type: 'text';
-    text: string;
-} | {
-    type: 'tool_call';
-    name: string;
-    arguments: string;
-} | {
-    type: 'tool_result';
-    name: string;
-    result: string;
-} | {
-    type: 'done';
-    response: AgentRunResponse;
-};
-export declare class SmoothAgent {
-    private readonly client;
-    private readonly options;
-    private readonly toolsByName;
-    constructor(client: ChatClientLike, options?: AgentOptions);
-    private buildSystem;
-    private toolSpecs;
-    /**
-     * Run a single turn.
-     *
-     * `history` is prior OpenAI-format messages (multi-turn). `thread`, when given,
-     * is a {@link SmoothAgentThread} carrying the conversation across runs: the turn
-     * is seeded from the thread's messages, and this turn's new user + assistant
-     * (+ tool) messages are appended back to it before returning. The thread takes
-     * precedence over `history` as the prior context.
-     */
-    run(message: string, history?: Array<Record<string, unknown>>, thread?: SmoothAgentThread): Promise<AgentRunResponse>;
-    /**
-     * Stream a single turn, yielding incremental {@link StreamEvent}s as the model
-     * produces them. This drives the SAME agentic loop as {@link run} (system /
-     * knowledge / memory build, seed messages, per-iteration compaction, cost
-     * tracking, budget early-stop, deferred-tool specs, clearance + human-gate on
-     * dispatch, checkpoint/thread persistence on exit) — but calls the model in
-     * STREAMING mode and emits events as work happens:
-     *
-     * - a `text` event per non-empty content delta as it streams in;
-     * - a `tool_call` event per requested tool call, after that iteration's model
-     *   stream ends, BEFORE the call is dispatched;
-     * - a `tool_result` event per tool, after it finishes (in original call order
-     *   even when `parallelToolCalls` runs them concurrently);
-     * - exactly one terminal `done` event carrying the same {@link AgentRunResponse}
-     *   {@link run} would return for the same script.
-     *
-     * NOTE: retry-with-backoff (`maxRetries`/`retryBackoffMs`) is intentionally NOT
-     * applied here — re-running the call after a mid-stream failure would re-emit
-     * already-yielded chunks. Retry stays scoped to non-streaming {@link run}; this
-     * mirrors the C# `RunStreamingAsync` decision.
-     */
-    runStream(message: string, history?: Array<Record<string, unknown>>, thread?: SmoothAgentThread): AsyncGenerator<StreamEvent>;
-    /**
-     * Invoke the model with bounded retry-with-exponential-backoff.
-     *
-     * On a transient error (anything the client throws — rate-limit, 5xx, dropped
-     * connection) the call is retried up to `maxRetries` additional times, waiting
-     * `retryBackoffMs * 2 ** (n - 1)` ms before the n-th (1-indexed) retry. If all
-     * attempts fail the LAST error propagates, so the turn fails exactly as it did
-     * before retries existed. Only this model call is retried — tool execution is not.
-     */
-    private callModel;
-    private dispatchTool;
-}
-/**
- * Build a {@link Tool} that delegates a subtask to a child {@link SmoothAgent}.
- *
- * A sub-agent is just a tool backed by another agent: the model calls this tool
- * with a `task` argument, the child agent runs that task, and the child's final
- * reply becomes the tool result — composing with the existing tool loop, no special
- * wiring. The child can have its own instructions, tools, knowledge, etc.
- */
-export declare function delegateTool(name: string, description: string, child: SmoothAgent, taskProperty?: string): Tool;
-//# sourceMappingURL=agent.d.ts.map

package/dist/agent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"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"}