@arnilo/prism 0.1.2 → 0.1.4

package/dist/agent-tool-dispatch.d.ts

@@ -0,0 +1,13 @@
+import type { StoredAgentRunState } from "./agent-run-state.js";
+import { Agent, AgentConfig, JsonObject, PendingDecision, ProviderRequestPolicy, ToolDefinition, ToolExecutionContext, ToolRegistry } from "./contracts.js";
+export declare function toolElicitationRequest(tool: ToolDefinition | undefined, args: JsonObject, context: ToolExecutionContext): {
+    schema: JsonObject;
+    reason?: string;
+} | undefined;
+/** Elicitation payload check: bounded JSON object, schema-required keys, host validator when configured. */
+export declare function validateElicitationPayload(agent: Agent, state: StoredAgentRunState, target: PendingDecision, payload: JsonObject, signal?: AbortSignal): Promise<void>;
+export declare function activeTools(tools: AgentConfig["tools"]): {
+    registry: ToolRegistry;
+    tools: readonly ToolDefinition[];
+};
+export declare function policyList(policies: ProviderRequestPolicy | readonly ProviderRequestPolicy[] | undefined): readonly ProviderRequestPolicy[];

package/dist/agent-tool-dispatch.js

@@ -0,0 +1,92 @@
+import { AgentDecisionError, HARD_MAX_ELICITATION_BYTES, MAX_DECISION_REASON_BYTES, MAX_ELICITATION_BYTES, } from "./contracts.js";
+import { createToolRegistry } from "./tools.js";
+export function toolElicitationRequest(tool, args, context) {
+    if (!tool?.elicitation)
+        return undefined;
+    let request;
+    try {
+        request = tool.elicitation(args, context);
+    }
+    catch {
+        return undefined;
+    }
+    if (!request)
+        return undefined;
+    const schemaText = JSON.stringify(request.schema);
+    if (schemaText === undefined || Buffer.byteLength(schemaText, "utf8") > HARD_MAX_ELICITATION_BYTES)
+        return undefined;
+    const reason = request.reason;
+    if (reason !== undefined && Buffer.byteLength(reason, "utf8") > MAX_DECISION_REASON_BYTES)
+        return { schema: request.schema };
+    return { schema: request.schema, ...(reason !== undefined ? { reason } : {}) };
+}
+/** Elicitation payload check: bounded JSON object, schema-required keys, host validator when configured. */
+export async function validateElicitationPayload(agent, state, target, payload, signal) {
+    const invalid = (message) => new AgentDecisionError("ERR_PRISM_DECISION_INVALID", message);
+    const text = JSON.stringify(payload);
+    if (text === undefined || Buffer.byteLength(text, "utf8") > MAX_ELICITATION_BYTES) {
+        throw new AgentDecisionError("ERR_PRISM_DECISION_LIMIT", `Elicitation payload exceeds ${MAX_ELICITATION_BYTES} bytes`);
+    }
+    const schema = target.elicitationSchema;
+    if (schema) {
+        const required = schema.required;
+        if (Array.isArray(required)) {
+            for (const key of required) {
+                if (typeof key === "string" && !Object.hasOwn(payload, key))
+                    throw invalid(`Elicitation payload missing required key ${key}`);
+            }
+        }
+        if (agent.config.validator) {
+            const tool = {
+                name: target.scope.toolName ?? "elicitation",
+                parameters: schema,
+                execute: () => ({ toolCallId: "", name: "elicitation" }),
+            };
+            const context = { sessionId: state.sessionId, runId: state.runId, toolCallId: target.toolCallId ?? "elicitation", signal };
+            const validation = await agent.config.validator(tool, payload, context);
+            if (validation)
+                throw invalid("Elicitation payload failed schema validation");
+        }
+    }
+    // Tool-declared answer-shape validation, re-derived from the current registry (never persisted).
+    const call = state.pendingCalls?.find((entry) => entry.call.id === target.toolCallId)?.call;
+    const tool = call ? activeTools(agent.config.tools).registry.get(call.name) : undefined;
+    const validate = tool?.elicitation && call
+        ? safeToolElicitationValidate(tool, call.arguments, {
+            sessionId: state.sessionId,
+            runId: state.runId,
+            toolCallId: target.toolCallId ?? "elicitation",
+            signal,
+        })
+        : undefined;
+    if (validate) {
+        try {
+            validate(payload);
+        }
+        catch (error) {
+            throw invalid(error instanceof Error ? error.message : "Elicitation payload rejected by tool validation");
+        }
+    }
+}
+function safeToolElicitationValidate(tool, args, context) {
+    try {
+        return tool.elicitation(args, context)?.validate;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function activeTools(tools) {
+    if (!tools)
+        return { registry: createToolRegistry(), tools: [] };
+    if ("list" in tools)
+        return { registry: tools, tools: tools.list() };
+    const registry = createToolRegistry(tools);
+    return { registry, tools };
+}
+export function policyList(policies) {
+    if (!policies)
+        return [];
+    return "apply" in policies ? [policies] : policies;
+}
+//# sourceMappingURL=agent-tool-dispatch.js.map

package/dist/agents.d.ts

@@ -1,9 +1,16 @@
-import type { Agent, AgentConfig, AgentEvent, AgentRunRef, AgentRunResult, AgentRunResume, AgentRunResumeOptions, AgentRunResumeStreamOptions, AgentSession, AgentSessionConfig } from "./contracts.js";
-export declare function createAgent(config: AgentConfig): Agent;
-export declare function createAgentSession(config: AgentSessionConfig & {
-    readonly agent: Agent;
-}): AgentSession;
-/** Resume a persisted built-in run. A claimed/dispatched tool is never replayed automatically. */
-export declare function resumeAgentRun(agent: Agent, ref: AgentRunRef, resume: AgentRunResume, options: AgentRunResumeOptions): Promise<AgentRunResult>;
-/** Subscribe before resuming one durable run. Early consumer return aborts that resumed execution. */
-export declare function resumeAgentRunStream(agent: Agent, ref: AgentRunRef, resume: AgentRunResume, options: AgentRunResumeStreamOptions): AsyncGenerator<AgentEvent>;
+/**
+ * Barrel for the agent runtime split at 0.1.4 (compat-preserving internal reorg).
+ * The four public exports (createAgent, createAgentSession, resumeAgentRun,
+ * resumeAgentRunStream) stay reachable through this barrel; RuntimeAgentSession,
+ * EventSubscriber, and the shared helpers live in agent-session.ts; the
+ * approval/pending-decision helpers in agent-approval.ts; the tool-dispatch
+ * helpers in agent-tool-dispatch.ts; the resume free functions in
+ * agent-run-lifecycle.ts; the fingerprint helpers in agent-run-state.ts.
+ *
+ * Deliberately NOT `export *`: star re-exports would surface the split modules'
+ * internal helpers (RuntimeAgentSession, pendingDecisionsOf, …) through
+ * agents.d.ts and change the declared surface — the 0.1.4 promise is an
+ * identical surface.
+ */
+export { createAgent, createAgentSession } from "./agent-session.js";
+export { resumeAgentRun, resumeAgentRunStream } from "./agent-run-lifecycle.js";