@nemesis-oss/ollama-sdk 1.1.0 → 1.4.0

package/dist/compose-BR70yb4W.d.cts

@@ -0,0 +1,164 @@
+import { T as ToolDefinition, a as ToolCall, M as Message } from './types-BQhgW-du.cjs';
+import { z } from 'zod';
+
+/**
+ * Tool definition, handler, and execution types.
+ */
+
+interface ToolExecutionContext {
+    readonly signal?: AbortSignal | undefined;
+}
+type ToolHandler<TParams, TResult> = (params: TParams, context: ToolExecutionContext) => Promise<TResult> | TResult;
+interface Tool<TParams = Record<string, unknown>, TResult = unknown> {
+    readonly name: string;
+    readonly description: string;
+    readonly schema: z.ZodType<TParams>;
+    readonly execute: ToolHandler<TParams, TResult>;
+    readonly definition: ToolDefinition;
+    /**
+     * Per-tool execution timeout in milliseconds, overriding the registry's default.
+     * Pass `0` to explicitly disable timeout enforcement for this tool.
+     */
+    readonly timeoutMs?: number | undefined;
+}
+/**
+ * A `Tool` of *any* parameter shape, for heterogeneous collections — i.e. what
+ * `ToolRegistry` stores and accepts.
+ *
+ * `Tool<TParams>` is **invariant** in `TParams`, because `TParams` appears both
+ * covariantly (`schema: z.ZodType<TParams>`) and contravariantly
+ * (`execute: ToolHandler<TParams, …>`). That makes `Tool<never, unknown>` — the obvious-
+ * looking "bottom" type for a mixed collection — assignable from *nothing*: a perfectly
+ * ordinary `Tool<{ city: string }, string>` from `defineTool` is rejected by it. `any` is
+ * the standard escape hatch for exactly this case, and it is confined to this one alias:
+ * `defineTool` still infers `TParams` from the Zod schema and still type-checks `execute`
+ * against it, so tool authoring keeps full type safety. Only the registry's *storage*
+ * type is widened, and the registry never does anything with a tool's params beyond
+ * handing `schema.safeParse`'s validated output straight back to that same tool's
+ * `execute`.
+ */
+type AnyTool = Tool<any, unknown>;
+interface ToolExecutionSuccess {
+    readonly toolName: string;
+    /** Echoes the originating {@link ToolCall.id}, if the call had one. */
+    readonly toolCallId?: string | undefined;
+    readonly success: true;
+    readonly result: unknown;
+    readonly outputString: string;
+}
+interface ToolExecutionFailure {
+    readonly toolName: string;
+    /** Echoes the originating {@link ToolCall.id}, if the call had one. */
+    readonly toolCallId?: string | undefined;
+    readonly success: false;
+    readonly error: Error;
+    readonly outputString: string;
+}
+type ToolExecutionResult = ToolExecutionSuccess | ToolExecutionFailure;
+
+/**
+ * Tool registry for managing definitions and executing model tool calls.
+ */
+
+interface ToolRegistryOptions {
+    readonly tools?: readonly AnyTool[] | undefined;
+    readonly onError?: ((error: Error, toolCall: ToolCall) => string) | undefined;
+    /**
+     * Default per-call execution timeout in milliseconds, applied to any tool that
+     * doesn't declare its own `timeoutMs`. Undefined (the default) means no timeout is
+     * enforced, matching prior behavior. Recommended whenever tool arguments or
+     * implementations are influenced by model output you don't fully control, since an
+     * unbounded tool call can otherwise stall the entire agent loop indefinitely.
+     *
+     * Enforcement is cooperative: it races the tool's promise against a timer and
+     * reports a timeout failure, but cannot forcibly halt synchronous or non-abort-aware
+     * asynchronous work already in flight on the same thread. Tools that perform I/O
+     * should honor `ToolExecutionContext.signal` to stop promptly on timeout.
+     */
+    readonly timeoutMs?: number | undefined;
+    /**
+     * Maximum number of tool calls executed concurrently by `executeToolCalls`.
+     * Undefined (the default) runs all calls in parallel, matching prior behavior.
+     */
+    readonly maxConcurrency?: number | undefined;
+    /**
+     * Maximum length of a tool's `outputString` before it is truncated. Guards against a
+     * single tool call flooding the conversation history / model context (and process
+     * memory) with unbounded output. Undefined (the default) applies no limit.
+     */
+    readonly maxOutputChars?: number | undefined;
+}
+declare class ToolRegistry {
+    private readonly tools;
+    private readonly onError?;
+    private readonly defaultTimeoutMs?;
+    private readonly maxConcurrency?;
+    private readonly maxOutputChars?;
+    constructor(toolsOrOptions?: readonly AnyTool[] | ToolRegistryOptions | undefined);
+    register(tool: AnyTool): this;
+    registerMany(tools: readonly AnyTool[]): this;
+    get(name: string): AnyTool | undefined;
+    definitions(): ToolDefinition[];
+    executeToolCall(toolCall: ToolCall, ctx?: ToolExecutionContext): Promise<ToolExecutionResult>;
+    private executeToolCallUninstrumented;
+    /**
+     * Executes every call in `toolCalls` and returns results in the same order, so results
+     * are always correlatable by array position regardless of `id`. Each result also echoes
+     * its call's `toolCallId` for callers who'd rather match by ID — see the {@link ToolCall}
+     * docs for how that id is produced. Runs fully in parallel (`Promise.all`) unless
+     * `maxConcurrency` was configured, in which case a bounded worker pool is used instead.
+     */
+    executeToolCalls(toolCalls: readonly ToolCall[], ctx?: ToolExecutionContext): Promise<ToolExecutionResult[]>;
+    private runWithTimeout;
+    private truncateOutput;
+    private handleExecutionError;
+}
+
+/**
+ * SKILL.md frontmatter and skill registry types.
+ */
+interface SkillFrontmatter {
+    readonly name: string;
+    readonly description: string;
+    readonly 'allowed-tools'?: readonly string[] | undefined;
+    readonly [key: string]: unknown;
+}
+interface SkillSummary {
+    readonly name: string;
+    readonly description: string;
+    readonly path: string;
+}
+interface Skill extends SkillSummary {
+    readonly frontmatter: SkillFrontmatter;
+    readonly body: string;
+    readonly allowedTools?: readonly string[] | undefined;
+}
+
+/**
+ * Lightweight frontmatter parser for SKILL.md files.
+ */
+
+interface ParsedFrontmatter {
+    readonly frontmatter: SkillFrontmatter;
+    readonly body: string;
+}
+declare function parseFrontmatter(source: string, path?: string): ParsedFrontmatter;
+
+/**
+ * Skill composition and context injection.
+ */
+
+interface ApplySkillOptions {
+    readonly messages: readonly Message[];
+    readonly tools?: ToolRegistry;
+}
+interface AppliedSkillResult {
+    readonly messages: readonly Message[];
+    readonly tools?: ToolRegistry;
+}
+/**
+ * Injects a skill's body into messages as a system prompt and applies allowed tool filters.
+ */
+declare function applySkill(skill: Skill, options: ApplySkillOptions): AppliedSkillResult;
+
+export { type AppliedSkillResult as A, type ParsedFrontmatter as P, type SkillSummary as S, type ToolHandler as T, type Skill as a, type ApplySkillOptions as b, type SkillFrontmatter as c, applySkill as d, type Tool as e, type AnyTool as f, ToolRegistry as g, type ToolExecutionResult as h, type ToolExecutionContext as i, type ToolExecutionFailure as j, type ToolExecutionSuccess as k, type ToolRegistryOptions as l, parseFrontmatter as p };

package/dist/compose-DfAqKAFj.d.ts

@@ -0,0 +1,164 @@
+import { T as ToolDefinition, a as ToolCall, M as Message } from './types-BQhgW-du.js';
+import { z } from 'zod';
+
+/**
+ * Tool definition, handler, and execution types.
+ */
+
+interface ToolExecutionContext {
+    readonly signal?: AbortSignal | undefined;
+}
+type ToolHandler<TParams, TResult> = (params: TParams, context: ToolExecutionContext) => Promise<TResult> | TResult;
+interface Tool<TParams = Record<string, unknown>, TResult = unknown> {
+    readonly name: string;
+    readonly description: string;
+    readonly schema: z.ZodType<TParams>;
+    readonly execute: ToolHandler<TParams, TResult>;
+    readonly definition: ToolDefinition;
+    /**
+     * Per-tool execution timeout in milliseconds, overriding the registry's default.
+     * Pass `0` to explicitly disable timeout enforcement for this tool.
+     */
+    readonly timeoutMs?: number | undefined;
+}
+/**
+ * A `Tool` of *any* parameter shape, for heterogeneous collections — i.e. what
+ * `ToolRegistry` stores and accepts.
+ *
+ * `Tool<TParams>` is **invariant** in `TParams`, because `TParams` appears both
+ * covariantly (`schema: z.ZodType<TParams>`) and contravariantly
+ * (`execute: ToolHandler<TParams, …>`). That makes `Tool<never, unknown>` — the obvious-
+ * looking "bottom" type for a mixed collection — assignable from *nothing*: a perfectly
+ * ordinary `Tool<{ city: string }, string>` from `defineTool` is rejected by it. `any` is
+ * the standard escape hatch for exactly this case, and it is confined to this one alias:
+ * `defineTool` still infers `TParams` from the Zod schema and still type-checks `execute`
+ * against it, so tool authoring keeps full type safety. Only the registry's *storage*
+ * type is widened, and the registry never does anything with a tool's params beyond
+ * handing `schema.safeParse`'s validated output straight back to that same tool's
+ * `execute`.
+ */
+type AnyTool = Tool<any, unknown>;
+interface ToolExecutionSuccess {
+    readonly toolName: string;
+    /** Echoes the originating {@link ToolCall.id}, if the call had one. */
+    readonly toolCallId?: string | undefined;
+    readonly success: true;
+    readonly result: unknown;
+    readonly outputString: string;
+}
+interface ToolExecutionFailure {
+    readonly toolName: string;
+    /** Echoes the originating {@link ToolCall.id}, if the call had one. */
+    readonly toolCallId?: string | undefined;
+    readonly success: false;
+    readonly error: Error;
+    readonly outputString: string;
+}
+type ToolExecutionResult = ToolExecutionSuccess | ToolExecutionFailure;
+
+/**
+ * Tool registry for managing definitions and executing model tool calls.
+ */
+
+interface ToolRegistryOptions {
+    readonly tools?: readonly AnyTool[] | undefined;
+    readonly onError?: ((error: Error, toolCall: ToolCall) => string) | undefined;
+    /**
+     * Default per-call execution timeout in milliseconds, applied to any tool that
+     * doesn't declare its own `timeoutMs`. Undefined (the default) means no timeout is
+     * enforced, matching prior behavior. Recommended whenever tool arguments or
+     * implementations are influenced by model output you don't fully control, since an
+     * unbounded tool call can otherwise stall the entire agent loop indefinitely.
+     *
+     * Enforcement is cooperative: it races the tool's promise against a timer and
+     * reports a timeout failure, but cannot forcibly halt synchronous or non-abort-aware
+     * asynchronous work already in flight on the same thread. Tools that perform I/O
+     * should honor `ToolExecutionContext.signal` to stop promptly on timeout.
+     */
+    readonly timeoutMs?: number | undefined;
+    /**
+     * Maximum number of tool calls executed concurrently by `executeToolCalls`.
+     * Undefined (the default) runs all calls in parallel, matching prior behavior.
+     */
+    readonly maxConcurrency?: number | undefined;
+    /**
+     * Maximum length of a tool's `outputString` before it is truncated. Guards against a
+     * single tool call flooding the conversation history / model context (and process
+     * memory) with unbounded output. Undefined (the default) applies no limit.
+     */
+    readonly maxOutputChars?: number | undefined;
+}
+declare class ToolRegistry {
+    private readonly tools;
+    private readonly onError?;
+    private readonly defaultTimeoutMs?;
+    private readonly maxConcurrency?;
+    private readonly maxOutputChars?;
+    constructor(toolsOrOptions?: readonly AnyTool[] | ToolRegistryOptions | undefined);
+    register(tool: AnyTool): this;
+    registerMany(tools: readonly AnyTool[]): this;
+    get(name: string): AnyTool | undefined;
+    definitions(): ToolDefinition[];
+    executeToolCall(toolCall: ToolCall, ctx?: ToolExecutionContext): Promise<ToolExecutionResult>;
+    private executeToolCallUninstrumented;
+    /**
+     * Executes every call in `toolCalls` and returns results in the same order, so results
+     * are always correlatable by array position regardless of `id`. Each result also echoes
+     * its call's `toolCallId` for callers who'd rather match by ID — see the {@link ToolCall}
+     * docs for how that id is produced. Runs fully in parallel (`Promise.all`) unless
+     * `maxConcurrency` was configured, in which case a bounded worker pool is used instead.
+     */
+    executeToolCalls(toolCalls: readonly ToolCall[], ctx?: ToolExecutionContext): Promise<ToolExecutionResult[]>;
+    private runWithTimeout;
+    private truncateOutput;
+    private handleExecutionError;
+}
+
+/**
+ * SKILL.md frontmatter and skill registry types.
+ */
+interface SkillFrontmatter {
+    readonly name: string;
+    readonly description: string;
+    readonly 'allowed-tools'?: readonly string[] | undefined;
+    readonly [key: string]: unknown;
+}
+interface SkillSummary {
+    readonly name: string;
+    readonly description: string;
+    readonly path: string;
+}
+interface Skill extends SkillSummary {
+    readonly frontmatter: SkillFrontmatter;
+    readonly body: string;
+    readonly allowedTools?: readonly string[] | undefined;
+}
+
+/**
+ * Lightweight frontmatter parser for SKILL.md files.
+ */
+
+interface ParsedFrontmatter {
+    readonly frontmatter: SkillFrontmatter;
+    readonly body: string;
+}
+declare function parseFrontmatter(source: string, path?: string): ParsedFrontmatter;
+
+/**
+ * Skill composition and context injection.
+ */
+
+interface ApplySkillOptions {
+    readonly messages: readonly Message[];
+    readonly tools?: ToolRegistry;
+}
+interface AppliedSkillResult {
+    readonly messages: readonly Message[];
+    readonly tools?: ToolRegistry;
+}
+/**
+ * Injects a skill's body into messages as a system prompt and applies allowed tool filters.
+ */
+declare function applySkill(skill: Skill, options: ApplySkillOptions): AppliedSkillResult;
+
+export { type AppliedSkillResult as A, type ParsedFrontmatter as P, type SkillSummary as S, type ToolHandler as T, type Skill as a, type ApplySkillOptions as b, type SkillFrontmatter as c, applySkill as d, type Tool as e, type AnyTool as f, ToolRegistry as g, type ToolExecutionResult as h, type ToolExecutionContext as i, type ToolExecutionFailure as j, type ToolExecutionSuccess as k, type ToolRegistryOptions as l, parseFrontmatter as p };