replyonce 0.0.0-stage → 0.1.1

package/dist/adapters.cjs

@@ -0,0 +1,260 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapters/index.ts
+var adapters_exports = {};
+__export(adapters_exports, {
+  ScopeBusyError: () => ScopeBusyError,
+  checkTool: () => checkTool,
+  describeOutcome: () => describeOutcome,
+  dispatchTool: () => dispatchTool,
+  guardTool: () => guardTool,
+  httpStatusFor: () => httpStatusFor,
+  onceProcessor: () => onceProcessor,
+  toAnthropicTool: () => toAnthropicTool,
+  toOpenAITool: () => toOpenAITool,
+  webhookOnce: () => webhookOnce
+});
+module.exports = __toCommonJS(adapters_exports);
+
+// src/adapters/tools.ts
+function guardTool(spec) {
+  const intent = spec.intent ?? spec.name;
+  return {
+    name: spec.name,
+    description: spec.description,
+    parameters: spec.parameters,
+    intent,
+    identity: spec.identity,
+    async call(run, args) {
+      const result = await run.once(intent, spec.identity(args), (ctx) => spec.execute(args, ctx), {
+        ...spec.summarize ? { summary: spec.summarize(args) } : {},
+        ...spec.conflict ? { conflict: spec.conflict } : {}
+      });
+      return describeOutcome(result);
+    }
+  };
+}
+function describeOutcome(result) {
+  switch (result.status) {
+    case "executed":
+      return { ok: true, status: "executed", terminal: false, retryable: false, message: "Done.", output: result.value };
+    case "replayed":
+      return {
+        ok: true,
+        status: "replayed",
+        terminal: false,
+        retryable: false,
+        message: "This exact action was already done earlier. It was not repeated.",
+        output: result.value
+      };
+    case "in_flight":
+      return {
+        ok: false,
+        status: "in_flight",
+        terminal: false,
+        retryable: false,
+        message: "This exact action is already in progress elsewhere. Do not repeat it."
+      };
+    case "ambiguous":
+      return {
+        ok: false,
+        status: "ambiguous",
+        terminal: false,
+        retryable: false,
+        message: "This action may or may not have happened (the outcome is unknown). Do not repeat it. Tell the user it is being checked, or escalate to a human."
+      };
+    case "failed":
+      return {
+        ok: false,
+        status: "failed",
+        terminal: false,
+        retryable: result.retryable,
+        message: result.retryable ? `The action failed and did not happen: ${errorText(result.error)}. You may retry.` : `The action failed and did not happen: ${errorText(result.error)}. Retry limit reached; escalate.`
+      };
+    case "refused": {
+      switch (result.reason) {
+        case "conversation_changed":
+          return {
+            ok: false,
+            status: "refused",
+            terminal: false,
+            retryable: true,
+            message: "Not done: the conversation changed since you last read it. Another run did the following. Re-read the conversation and decide whether your action is still needed; if it is, call the tool again.",
+            conflicts: (result.conflicts ?? []).map((c) => ({ intent: c.intent, status: c.status, summary: c.summary }))
+          };
+        case "exhausted":
+          return {
+            ok: false,
+            status: "refused",
+            terminal: false,
+            retryable: false,
+            message: "Not done: this action already failed too many times. Escalate to a human."
+          };
+        default:
+          return {
+            ok: false,
+            status: "refused",
+            terminal: true,
+            retryable: false,
+            message: `Stop: this run may no longer act on this conversation (${result.reason}).`
+          };
+      }
+    }
+  }
+}
+function checkTool(tools, name = "check_already_done") {
+  const byName = new Map(tools.map((t) => [t.name, t]));
+  return {
+    name,
+    description: "Check whether a side-effecting action was already done on this conversation before doing it again. Pass the tool name and the arguments you would call it with. Omit arguments to list every recorded call of that tool.",
+    parameters: {
+      type: "object",
+      properties: {
+        tool: { type: "string", enum: tools.map((t) => t.name) },
+        arguments: { type: "object", description: "The arguments you would pass to that tool." }
+      },
+      required: ["tool"],
+      additionalProperties: false
+    },
+    intent: name,
+    identity: (args) => args,
+    async call(run, args) {
+      const tool = byName.get(args?.tool);
+      if (!tool) {
+        return { ok: false, status: "failed", terminal: false, retryable: false, message: `Unknown tool ${String(args?.tool)}.` };
+      }
+      if (args.arguments !== void 0) {
+        const found = await run.check(tool.intent, tool.identity(args.arguments));
+        const message = found.status === "none" ? "Not done yet." : found.status === "committed" ? "Already done. Do not repeat it." : found.status === "failed" ? "Tried before and it did not happen. It may be retried." : found.status === "pending" ? "In progress right now. Do not repeat it." : "Outcome unknown. Do not repeat it; escalate.";
+        return {
+          ok: true,
+          status: "executed",
+          terminal: false,
+          retryable: false,
+          message,
+          output: { status: found.status, done: found.done, summary: found.entry?.summary ?? null }
+        };
+      }
+      const all = (await run.history()).filter((e) => e.intent === tool.intent);
+      return {
+        ok: true,
+        status: "executed",
+        terminal: false,
+        retryable: false,
+        message: all.length === 0 ? "No calls recorded." : `${all.length} call(s) recorded.`,
+        output: all.map((e) => ({ status: e.status, summary: e.summary, at: new Date(e.settledAt ?? e.claimedAt).toISOString() }))
+      };
+    }
+  };
+}
+async function dispatchTool(run, tools, name, args) {
+  const tool = tools.find((t) => t.name === name);
+  if (!tool) {
+    return { ok: false, status: "failed", terminal: false, retryable: false, message: `Unknown tool ${name}.` };
+  }
+  return tool.call(run, args);
+}
+function toOpenAITool(tool, api = "chat") {
+  if (api === "responses") {
+    return { type: "function", name: tool.name, description: tool.description, parameters: tool.parameters };
+  }
+  return { type: "function", function: { name: tool.name, description: tool.description, parameters: tool.parameters } };
+}
+function toAnthropicTool(tool) {
+  return { name: tool.name, description: tool.description, input_schema: tool.parameters };
+}
+function errorText(err) {
+  return (err instanceof Error ? err.message : String(err)).slice(0, 300);
+}
+
+// src/adapters/webhook.ts
+function httpStatusFor(result) {
+  switch (result.status) {
+    case "executed":
+    case "replayed":
+      return { status: 200 };
+    case "in_flight":
+      return { status: 503, retryAfter: 5 };
+    case "failed":
+      return result.retryable ? { status: 500 } : { status: 200 };
+    default:
+      return { status: 200 };
+  }
+}
+async function webhookOnce(ro, input, handler) {
+  const { scope, eventId, intent = "webhook", ...options } = input;
+  const result = await ro.once({ scope, intent, payload: { eventId } }, handler, options);
+  return { result, ...httpStatusFor(result) };
+}
+
+// src/adapters/bullmq.ts
+var ScopeBusyError = class extends Error {
+  holderRunId;
+  constructor(scope, holderRunId) {
+    super(`replyonce: scope ${JSON.stringify(scope)} is held by run ${holderRunId}`);
+    this.name = "ScopeBusyError";
+    this.holderRunId = holderRunId;
+  }
+};
+function onceProcessor(ro, options, processor) {
+  return async (job) => {
+    const scope = options.scope(job);
+    if (!options.runId && !job.id) throw new TypeError("replyonce: job has no id; pass options.runId");
+    const runId = options.runId ? options.runId(job) : job.queueName ? `${job.queueName}:${job.id}` : job.id;
+    const run = await ro.begin(scope, { runId, ...options.mode ? { mode: options.mode } : {} });
+    const skip = (reason) => {
+      options.onSkip?.(job, reason);
+      return { replyonce: "skipped", reason };
+    };
+    if (run.state === "busy") throw new ScopeBusyError(scope, run.busyHolder.runId);
+    if (run.state === "ended") return skip("ended");
+    if (run.state === "superseded") {
+      await run.end("cancelled");
+      return skip("superseded");
+    }
+    if (run.state === "resumed" && run.alreadyWrote && options.onRedeliveredAfterWrite === "skip") {
+      await run.end("failed");
+      return skip("redelivered_after_write");
+    }
+    try {
+      const out = await processor(job, run);
+      await run.end("completed");
+      return out;
+    } catch (err) {
+      const attempts = job.opts?.attempts ?? 1;
+      if (job.attemptsMade + 1 >= attempts) await run.end("failed").catch(() => void 0);
+      throw err;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ScopeBusyError,
+  checkTool,
+  describeOutcome,
+  dispatchTool,
+  guardTool,
+  httpStatusFor,
+  onceProcessor,
+  toAnthropicTool,
+  toOpenAITool,
+  webhookOnce
+});
+//# sourceMappingURL=adapters.cjs.map

package/dist/adapters.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/adapters/index.ts","../src/adapters/tools.ts","../src/adapters/webhook.ts","../src/adapters/bullmq.ts"],"sourcesContent":["export {\n  checkTool,\n  describeOutcome,\n  dispatchTool,\n  guardTool,\n  toAnthropicTool,\n  toOpenAITool,\n} from './tools.js';\nexport type { GuardedTool, GuardedToolSpec, JsonSchema, ToolDefinition, ToolOutcome } from './tools.js';\nexport { httpStatusFor, webhookOnce } from './webhook.js';\nexport type { WebhookOnceInput, WebhookOnceResponse } from './webhook.js';\nexport { ScopeBusyError, onceProcessor } from './bullmq.js';\nexport type { JobLike, OnceProcessorOptions, SkipReason, Skipped } from './bullmq.js';\n","import type { ConflictMode } from '../logic.js';\nimport type { Run } from '../replyonce.js';\nimport type { ConflictInfo, EffectContext, OnceResult } from '../types.js';\n\nexport type JsonSchema = Record<string, unknown>;\n\nexport interface ToolDefinition {\n  name: string;\n  description: string;\n  parameters: JsonSchema;\n}\n\nexport interface GuardedToolSpec<A, R> extends ToolDefinition {\n  /** Ledger intent. Defaults to the tool name. */\n  intent?: string;\n  /**\n   * The business identity of the action, from its arguments: what makes two calls \"the\n   * same action\". For a reply, the inbound message being answered; for a refund, the\n   * order and amount. Never the model's tool-call id.\n   */\n  identity: (args: A) => unknown;\n  /** Short text other runs see if this write conflicts with theirs. */\n  summarize?: (args: A) => string;\n  conflict?: ConflictMode;\n  execute: (args: A, ctx: EffectContext) => Promise<R> | R;\n}\n\n/** What to hand back to the model. `terminal` means the run should stop. */\nexport interface ToolOutcome {\n  ok: boolean;\n  status: OnceResult<unknown>['status'];\n  terminal: boolean;\n  retryable: boolean;\n  message: string;\n  output?: unknown;\n  conflicts?: Array<Pick<ConflictInfo, 'intent' | 'status' | 'summary'>>;\n}\n\nexport interface GuardedTool<A = any, R = unknown> extends ToolDefinition {\n  intent: string;\n  identity: (args: A) => unknown;\n  call(run: Run, args: A): Promise<ToolOutcome>;\n}\n\n/** Wrap a side-effecting tool so a run executes it at most once per business identity. */\nexport function guardTool<A, R>(spec: GuardedToolSpec<A, R>): GuardedTool<A, R> {\n  const intent = spec.intent ?? spec.name;\n  return {\n    name: spec.name,\n    description: spec.description,\n    parameters: spec.parameters,\n    intent,\n    identity: spec.identity,\n    async call(run, args) {\n      const result = await run.once(intent, spec.identity(args), (ctx) => spec.execute(args, ctx), {\n        ...(spec.summarize ? { summary: spec.summarize(args) } : {}),\n        ...(spec.conflict ? { conflict: spec.conflict } : {}),\n      });\n      return describeOutcome(result);\n    },\n  };\n}\n\n/** Turn a `once` result into a model-friendly tool result. */\nexport function describeOutcome(result: OnceResult<unknown>): ToolOutcome {\n  switch (result.status) {\n    case 'executed':\n      return { ok: true, status: 'executed', terminal: false, retryable: false, message: 'Done.', output: result.value };\n    case 'replayed':\n      return {\n        ok: true,\n        status: 'replayed',\n        terminal: false,\n        retryable: false,\n        message: 'This exact action was already done earlier. It was not repeated.',\n        output: result.value,\n      };\n    case 'in_flight':\n      return {\n        ok: false,\n        status: 'in_flight',\n        terminal: false,\n        retryable: false,\n        message: 'This exact action is already in progress elsewhere. Do not repeat it.',\n      };\n    case 'ambiguous':\n      return {\n        ok: false,\n        status: 'ambiguous',\n        terminal: false,\n        retryable: false,\n        message:\n          'This action may or may not have happened (the outcome is unknown). Do not repeat it. ' +\n          'Tell the user it is being checked, or escalate to a human.',\n      };\n    case 'failed':\n      return {\n        ok: false,\n        status: 'failed',\n        terminal: false,\n        retryable: result.retryable,\n        message: result.retryable\n          ? `The action failed and did not happen: ${errorText(result.error)}. You may retry.`\n          : `The action failed and did not happen: ${errorText(result.error)}. Retry limit reached; escalate.`,\n      };\n    case 'refused': {\n      switch (result.reason) {\n        case 'conversation_changed':\n          return {\n            ok: false,\n            status: 'refused',\n            terminal: false,\n            retryable: true,\n            message:\n              'Not done: the conversation changed since you last read it. Another run did the following. ' +\n              'Re-read the conversation and decide whether your action is still needed; if it is, call the tool again.',\n            conflicts: (result.conflicts ?? []).map((c) => ({ intent: c.intent, status: c.status, summary: c.summary })),\n          };\n        case 'exhausted':\n          return {\n            ok: false,\n            status: 'refused',\n            terminal: false,\n            retryable: false,\n            message: 'Not done: this action already failed too many times. Escalate to a human.',\n          };\n        default:\n          return {\n            ok: false,\n            status: 'refused',\n            terminal: true,\n            retryable: false,\n            message: `Stop: this run may no longer act on this conversation (${result.reason}).`,\n          };\n      }\n    }\n  }\n}\n\n/**\n * A read-only \"was this already done?\" tool. Given a guarded tool name and, optionally,\n * its arguments, it reports what the ledger knows. Add it alongside your write tools.\n */\nexport function checkTool(tools: GuardedTool[], name = 'check_already_done'): GuardedTool<{ tool: string; arguments?: unknown }, unknown> {\n  const byName = new Map(tools.map((t) => [t.name, t]));\n  return {\n    name,\n    description:\n      'Check whether a side-effecting action was already done on this conversation before doing it again. ' +\n      'Pass the tool name and the arguments you would call it with. Omit arguments to list every recorded call of that tool.',\n    parameters: {\n      type: 'object',\n      properties: {\n        tool: { type: 'string', enum: tools.map((t) => t.name) },\n        arguments: { type: 'object', description: 'The arguments you would pass to that tool.' },\n      },\n      required: ['tool'],\n      additionalProperties: false,\n    },\n    intent: name,\n    identity: (args) => args,\n    async call(run, args) {\n      const tool = byName.get(args?.tool);\n      if (!tool) {\n        return { ok: false, status: 'failed', terminal: false, retryable: false, message: `Unknown tool ${String(args?.tool)}.` };\n      }\n      if (args.arguments !== undefined) {\n        const found = await run.check(tool.intent, tool.identity(args.arguments));\n        const message =\n          found.status === 'none'\n            ? 'Not done yet.'\n            : found.status === 'committed'\n              ? 'Already done. Do not repeat it.'\n              : found.status === 'failed'\n                ? 'Tried before and it did not happen. It may be retried.'\n                : found.status === 'pending'\n                  ? 'In progress right now. Do not repeat it.'\n                  : 'Outcome unknown. Do not repeat it; escalate.';\n        return {\n          ok: true,\n          status: 'executed',\n          terminal: false,\n          retryable: false,\n          message,\n          output: { status: found.status, done: found.done, summary: found.entry?.summary ?? null },\n        };\n      }\n      const all = (await run.history()).filter((e) => e.intent === tool.intent);\n      return {\n        ok: true,\n        status: 'executed',\n        terminal: false,\n        retryable: false,\n        message: all.length === 0 ? 'No calls recorded.' : `${all.length} call(s) recorded.`,\n        output: all.map((e) => ({ status: e.status, summary: e.summary, at: new Date(e.settledAt ?? e.claimedAt).toISOString() })),\n      };\n    },\n  };\n}\n\n/** Route a model's tool call to the matching guarded tool. */\nexport async function dispatchTool(run: Run, tools: GuardedTool[], name: string, args: unknown): Promise<ToolOutcome> {\n  const tool = tools.find((t) => t.name === name);\n  if (!tool) {\n    return { ok: false, status: 'failed', terminal: false, retryable: false, message: `Unknown tool ${name}.` };\n  }\n  return tool.call(run, args);\n}\n\n/** OpenAI tool shape. `chat` for Chat Completions, `responses` for the Responses API. */\nexport function toOpenAITool(tool: ToolDefinition, api: 'chat' | 'responses' = 'chat'): Record<string, unknown> {\n  if (api === 'responses') {\n    return { type: 'function', name: tool.name, description: tool.description, parameters: tool.parameters };\n  }\n  return { type: 'function', function: { name: tool.name, description: tool.description, parameters: tool.parameters } };\n}\n\n/** Anthropic Messages API tool shape. */\nexport function toAnthropicTool(tool: ToolDefinition): Record<string, unknown> {\n  return { name: tool.name, description: tool.description, input_schema: tool.parameters };\n}\n\nfunction errorText(err: unknown): string {\n  return (err instanceof Error ? err.message : String(err)).slice(0, 300);\n}\n","import type { Effect, OnceOptions, ReplyOnce } from '../replyonce.js';\nimport type { OnceResult } from '../types.js';\n\nexport interface WebhookOnceInput extends OnceOptions {\n  /** Usually the conversation, ticket or channel the event belongs to. */\n  scope: string;\n  /** The provider's stable id for the event (for example Slack's `event_id`). */\n  eventId: string;\n  /** Ledger intent. Default `webhook`. */\n  intent?: string;\n}\n\nexport interface WebhookOnceResponse<T> {\n  result: OnceResult<T>;\n  /** Suggested HTTP status for the provider. See `httpStatusFor`. */\n  status: number;\n  /** Seconds, set when the provider should retry later. */\n  retryAfter?: number;\n}\n\n/**\n * Suggested response so at-least-once delivery keeps working without duplicating effects:\n *\n * - executed / replayed: 200, the event is handled.\n * - in_flight: 503 + Retry-After. Another delivery is still processing it; if that one\n *   crashes, the provider's retry picks it up.\n * - failed and retryable: 500, let the provider retry.\n * - ambiguous, exhausted, or refused: 200. Redelivery cannot fix these; alert and reconcile.\n */\nexport function httpStatusFor(result: OnceResult<unknown>): { status: number; retryAfter?: number } {\n  switch (result.status) {\n    case 'executed':\n    case 'replayed':\n      return { status: 200 };\n    case 'in_flight':\n      return { status: 503, retryAfter: 5 };\n    case 'failed':\n      return result.retryable ? { status: 500 } : { status: 200 };\n    default:\n      return { status: 200 };\n  }\n}\n\n/** Handle one webhook delivery at most once per (scope, eventId), however often it is redelivered. */\nexport async function webhookOnce<T>(\n  ro: ReplyOnce,\n  input: WebhookOnceInput,\n  handler: Effect<T>,\n): Promise<WebhookOnceResponse<T>> {\n  const { scope, eventId, intent = 'webhook', ...options } = input;\n  const result = await ro.once({ scope, intent, payload: { eventId } }, handler, options);\n  return { result, ...httpStatusFor(result) };\n}\n","import type { ReplyOnce, Run } from '../replyonce.js';\nimport type { RunMode } from '../types.js';\n\n/** The parts of a BullMQ `Job` replyonce reads. */\nexport interface JobLike<D = unknown> {\n  id?: string;\n  name?: string;\n  queueName?: string;\n  data: D;\n  attemptsMade: number;\n  opts?: { attempts?: number };\n}\n\nexport interface OnceProcessorOptions<D> {\n  /** Scope of the job, usually the conversation id. */\n  scope: (job: JobLike<D>) => string;\n  /**\n   * Stable run id. Default: `<queueName>:<job id>`. BullMQ keeps the job id across retries\n   * and stalled redelivery, but ids are only unique within one queue.\n   */\n  runId?: (job: JobLike<D>) => string;\n  mode?: RunMode;\n  /**\n   * A redelivered job whose run already claimed a write. `resume` (default) runs the\n   * processor again; every `run.once` it already completed is replayed, not repeated.\n   * `skip` never re-runs it, for processors whose effect identities are not deterministic.\n   */\n  onRedeliveredAfterWrite?: 'resume' | 'skip';\n  onSkip?: (job: JobLike<D>, reason: SkipReason) => void;\n}\n\nexport type SkipReason = 'ended' | 'superseded' | 'redelivered_after_write';\n\nexport interface Skipped {\n  replyonce: 'skipped';\n  reason: SkipReason;\n}\n\n/** Thrown in `exclusive` mode while another live worker holds the scope, so the queue retries later. */\nexport class ScopeBusyError extends Error {\n  readonly holderRunId: string;\n  constructor(scope: string, holderRunId: string) {\n    super(`replyonce: scope ${JSON.stringify(scope)} is held by run ${holderRunId}`);\n    this.name = 'ScopeBusyError';\n    this.holderRunId = holderRunId;\n  }\n}\n\n/**\n * Wrap a BullMQ processor. Each job becomes a replyonce run keyed by job id, so retries\n * and stalled-job redelivery resume the same run and its completed effects are not redone.\n */\nexport function onceProcessor<D, R>(\n  ro: ReplyOnce,\n  options: OnceProcessorOptions<D>,\n  processor: (job: JobLike<D>, run: Run) => Promise<R>,\n): (job: JobLike<D>) => Promise<R | Skipped> {\n  return async (job) => {\n    const scope = options.scope(job);\n    if (!options.runId && !job.id) throw new TypeError('replyonce: job has no id; pass options.runId');\n    const runId = options.runId ? options.runId(job) : job.queueName ? `${job.queueName}:${job.id}` : job.id!;\n    const run = await ro.begin(scope, { runId, ...(options.mode ? { mode: options.mode } : {}) });\n\n    const skip = (reason: SkipReason): Skipped => {\n      options.onSkip?.(job, reason);\n      return { replyonce: 'skipped', reason };\n    };\n    if (run.state === 'busy') throw new ScopeBusyError(scope, run.busyHolder!.runId);\n    if (run.state === 'ended') return skip('ended');\n    if (run.state === 'superseded') {\n      await run.end('cancelled');\n      return skip('superseded');\n    }\n    if (run.state === 'resumed' && run.alreadyWrote && options.onRedeliveredAfterWrite === 'skip') {\n      await run.end('failed');\n      return skip('redelivered_after_write');\n    }\n\n    try {\n      const out = await processor(job, run);\n      await run.end('completed');\n      return out;\n    } catch (err) {\n      const attempts = job.opts?.attempts ?? 1;\n      if (job.attemptsMade + 1 >= attempts) await run.end('failed').catch(() => undefined);\n      throw err;\n    }\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/adapters.d.cts

@@ -0,0 +1,134 @@
+import { Run, ConflictMode, OnceOptions, ReplyOnce, Effect } from './index.cjs';
+import { OnceResult, ConflictInfo, EffectContext, RunMode } from './index.cjs';
+
+type JsonSchema = Record<string, unknown>;
+interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: JsonSchema;
+}
+interface GuardedToolSpec<A, R> extends ToolDefinition {
+    /** Ledger intent. Defaults to the tool name. */
+    intent?: string;
+    /**
+     * The business identity of the action, from its arguments: what makes two calls "the
+     * same action". For a reply, the inbound message being answered; for a refund, the
+     * order and amount. Never the model's tool-call id.
+     */
+    identity: (args: A) => unknown;
+    /** Short text other runs see if this write conflicts with theirs. */
+    summarize?: (args: A) => string;
+    conflict?: ConflictMode;
+    execute: (args: A, ctx: EffectContext) => Promise<R> | R;
+}
+/** What to hand back to the model. `terminal` means the run should stop. */
+interface ToolOutcome {
+    ok: boolean;
+    status: OnceResult<unknown>['status'];
+    terminal: boolean;
+    retryable: boolean;
+    message: string;
+    output?: unknown;
+    conflicts?: Array<Pick<ConflictInfo, 'intent' | 'status' | 'summary'>>;
+}
+interface GuardedTool<A = any, R = unknown> extends ToolDefinition {
+    intent: string;
+    identity: (args: A) => unknown;
+    call(run: Run, args: A): Promise<ToolOutcome>;
+}
+/** Wrap a side-effecting tool so a run executes it at most once per business identity. */
+declare function guardTool<A, R>(spec: GuardedToolSpec<A, R>): GuardedTool<A, R>;
+/** Turn a `once` result into a model-friendly tool result. */
+declare function describeOutcome(result: OnceResult<unknown>): ToolOutcome;
+/**
+ * A read-only "was this already done?" tool. Given a guarded tool name and, optionally,
+ * its arguments, it reports what the ledger knows. Add it alongside your write tools.
+ */
+declare function checkTool(tools: GuardedTool[], name?: string): GuardedTool<{
+    tool: string;
+    arguments?: unknown;
+}, unknown>;
+/** Route a model's tool call to the matching guarded tool. */
+declare function dispatchTool(run: Run, tools: GuardedTool[], name: string, args: unknown): Promise<ToolOutcome>;
+/** OpenAI tool shape. `chat` for Chat Completions, `responses` for the Responses API. */
+declare function toOpenAITool(tool: ToolDefinition, api?: 'chat' | 'responses'): Record<string, unknown>;
+/** Anthropic Messages API tool shape. */
+declare function toAnthropicTool(tool: ToolDefinition): Record<string, unknown>;
+
+interface WebhookOnceInput extends OnceOptions {
+    /** Usually the conversation, ticket or channel the event belongs to. */
+    scope: string;
+    /** The provider's stable id for the event (for example Slack's `event_id`). */
+    eventId: string;
+    /** Ledger intent. Default `webhook`. */
+    intent?: string;
+}
+interface WebhookOnceResponse<T> {
+    result: OnceResult<T>;
+    /** Suggested HTTP status for the provider. See `httpStatusFor`. */
+    status: number;
+    /** Seconds, set when the provider should retry later. */
+    retryAfter?: number;
+}
+/**
+ * Suggested response so at-least-once delivery keeps working without duplicating effects:
+ *
+ * - executed / replayed: 200, the event is handled.
+ * - in_flight: 503 + Retry-After. Another delivery is still processing it; if that one
+ *   crashes, the provider's retry picks it up.
+ * - failed and retryable: 500, let the provider retry.
+ * - ambiguous, exhausted, or refused: 200. Redelivery cannot fix these; alert and reconcile.
+ */
+declare function httpStatusFor(result: OnceResult<unknown>): {
+    status: number;
+    retryAfter?: number;
+};
+/** Handle one webhook delivery at most once per (scope, eventId), however often it is redelivered. */
+declare function webhookOnce<T>(ro: ReplyOnce, input: WebhookOnceInput, handler: Effect<T>): Promise<WebhookOnceResponse<T>>;
+
+/** The parts of a BullMQ `Job` replyonce reads. */
+interface JobLike<D = unknown> {
+    id?: string;
+    name?: string;
+    queueName?: string;
+    data: D;
+    attemptsMade: number;
+    opts?: {
+        attempts?: number;
+    };
+}
+interface OnceProcessorOptions<D> {
+    /** Scope of the job, usually the conversation id. */
+    scope: (job: JobLike<D>) => string;
+    /**
+     * Stable run id. Default: `<queueName>:<job id>`. BullMQ keeps the job id across retries
+     * and stalled redelivery, but ids are only unique within one queue.
+     */
+    runId?: (job: JobLike<D>) => string;
+    mode?: RunMode;
+    /**
+     * A redelivered job whose run already claimed a write. `resume` (default) runs the
+     * processor again; every `run.once` it already completed is replayed, not repeated.
+     * `skip` never re-runs it, for processors whose effect identities are not deterministic.
+     */
+    onRedeliveredAfterWrite?: 'resume' | 'skip';
+    onSkip?: (job: JobLike<D>, reason: SkipReason) => void;
+}
+type SkipReason = 'ended' | 'superseded' | 'redelivered_after_write';
+interface Skipped {
+    replyonce: 'skipped';
+    reason: SkipReason;
+}
+/** Thrown in `exclusive` mode while another live worker holds the scope, so the queue retries later. */
+declare class ScopeBusyError extends Error {
+    readonly holderRunId: string;
+    constructor(scope: string, holderRunId: string);
+}
+/**
+ * Wrap a BullMQ processor. Each job becomes a replyonce run keyed by job id, so retries
+ * and stalled-job redelivery resume the same run and its completed effects are not redone.
+ */
+declare function onceProcessor<D, R>(ro: ReplyOnce, options: OnceProcessorOptions<D>, processor: (job: JobLike<D>, run: Run) => Promise<R>): (job: JobLike<D>) => Promise<R | Skipped>;
+
+export { ScopeBusyError, checkTool, describeOutcome, dispatchTool, guardTool, httpStatusFor, onceProcessor, toAnthropicTool, toOpenAITool, webhookOnce };
+export type { GuardedTool, GuardedToolSpec, JobLike, JsonSchema, OnceProcessorOptions, SkipReason, Skipped, ToolDefinition, ToolOutcome, WebhookOnceInput, WebhookOnceResponse };

package/dist/adapters.d.ts

@@ -0,0 +1,134 @@
+import { Run, ConflictMode, OnceOptions, ReplyOnce, Effect } from './index.js';
+import { OnceResult, ConflictInfo, EffectContext, RunMode } from './index.js';
+
+type JsonSchema = Record<string, unknown>;
+interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: JsonSchema;
+}
+interface GuardedToolSpec<A, R> extends ToolDefinition {
+    /** Ledger intent. Defaults to the tool name. */
+    intent?: string;
+    /**
+     * The business identity of the action, from its arguments: what makes two calls "the
+     * same action". For a reply, the inbound message being answered; for a refund, the
+     * order and amount. Never the model's tool-call id.
+     */
+    identity: (args: A) => unknown;
+    /** Short text other runs see if this write conflicts with theirs. */
+    summarize?: (args: A) => string;
+    conflict?: ConflictMode;
+    execute: (args: A, ctx: EffectContext) => Promise<R> | R;
+}
+/** What to hand back to the model. `terminal` means the run should stop. */
+interface ToolOutcome {
+    ok: boolean;
+    status: OnceResult<unknown>['status'];
+    terminal: boolean;
+    retryable: boolean;
+    message: string;
+    output?: unknown;
+    conflicts?: Array<Pick<ConflictInfo, 'intent' | 'status' | 'summary'>>;
+}
+interface GuardedTool<A = any, R = unknown> extends ToolDefinition {
+    intent: string;
+    identity: (args: A) => unknown;
+    call(run: Run, args: A): Promise<ToolOutcome>;
+}
+/** Wrap a side-effecting tool so a run executes it at most once per business identity. */
+declare function guardTool<A, R>(spec: GuardedToolSpec<A, R>): GuardedTool<A, R>;
+/** Turn a `once` result into a model-friendly tool result. */
+declare function describeOutcome(result: OnceResult<unknown>): ToolOutcome;
+/**
+ * A read-only "was this already done?" tool. Given a guarded tool name and, optionally,
+ * its arguments, it reports what the ledger knows. Add it alongside your write tools.
+ */
+declare function checkTool(tools: GuardedTool[], name?: string): GuardedTool<{
+    tool: string;
+    arguments?: unknown;
+}, unknown>;
+/** Route a model's tool call to the matching guarded tool. */
+declare function dispatchTool(run: Run, tools: GuardedTool[], name: string, args: unknown): Promise<ToolOutcome>;
+/** OpenAI tool shape. `chat` for Chat Completions, `responses` for the Responses API. */
+declare function toOpenAITool(tool: ToolDefinition, api?: 'chat' | 'responses'): Record<string, unknown>;
+/** Anthropic Messages API tool shape. */
+declare function toAnthropicTool(tool: ToolDefinition): Record<string, unknown>;
+
+interface WebhookOnceInput extends OnceOptions {
+    /** Usually the conversation, ticket or channel the event belongs to. */
+    scope: string;
+    /** The provider's stable id for the event (for example Slack's `event_id`). */
+    eventId: string;
+    /** Ledger intent. Default `webhook`. */
+    intent?: string;
+}
+interface WebhookOnceResponse<T> {
+    result: OnceResult<T>;
+    /** Suggested HTTP status for the provider. See `httpStatusFor`. */
+    status: number;
+    /** Seconds, set when the provider should retry later. */
+    retryAfter?: number;
+}
+/**
+ * Suggested response so at-least-once delivery keeps working without duplicating effects:
+ *
+ * - executed / replayed: 200, the event is handled.
+ * - in_flight: 503 + Retry-After. Another delivery is still processing it; if that one
+ *   crashes, the provider's retry picks it up.
+ * - failed and retryable: 500, let the provider retry.
+ * - ambiguous, exhausted, or refused: 200. Redelivery cannot fix these; alert and reconcile.
+ */
+declare function httpStatusFor(result: OnceResult<unknown>): {
+    status: number;
+    retryAfter?: number;
+};
+/** Handle one webhook delivery at most once per (scope, eventId), however often it is redelivered. */
+declare function webhookOnce<T>(ro: ReplyOnce, input: WebhookOnceInput, handler: Effect<T>): Promise<WebhookOnceResponse<T>>;
+
+/** The parts of a BullMQ `Job` replyonce reads. */
+interface JobLike<D = unknown> {
+    id?: string;
+    name?: string;
+    queueName?: string;
+    data: D;
+    attemptsMade: number;
+    opts?: {
+        attempts?: number;
+    };
+}
+interface OnceProcessorOptions<D> {
+    /** Scope of the job, usually the conversation id. */
+    scope: (job: JobLike<D>) => string;
+    /**
+     * Stable run id. Default: `<queueName>:<job id>`. BullMQ keeps the job id across retries
+     * and stalled redelivery, but ids are only unique within one queue.
+     */
+    runId?: (job: JobLike<D>) => string;
+    mode?: RunMode;
+    /**
+     * A redelivered job whose run already claimed a write. `resume` (default) runs the
+     * processor again; every `run.once` it already completed is replayed, not repeated.
+     * `skip` never re-runs it, for processors whose effect identities are not deterministic.
+     */
+    onRedeliveredAfterWrite?: 'resume' | 'skip';
+    onSkip?: (job: JobLike<D>, reason: SkipReason) => void;
+}
+type SkipReason = 'ended' | 'superseded' | 'redelivered_after_write';
+interface Skipped {
+    replyonce: 'skipped';
+    reason: SkipReason;
+}
+/** Thrown in `exclusive` mode while another live worker holds the scope, so the queue retries later. */
+declare class ScopeBusyError extends Error {
+    readonly holderRunId: string;
+    constructor(scope: string, holderRunId: string);
+}
+/**
+ * Wrap a BullMQ processor. Each job becomes a replyonce run keyed by job id, so retries
+ * and stalled-job redelivery resume the same run and its completed effects are not redone.
+ */
+declare function onceProcessor<D, R>(ro: ReplyOnce, options: OnceProcessorOptions<D>, processor: (job: JobLike<D>, run: Run) => Promise<R>): (job: JobLike<D>) => Promise<R | Skipped>;
+
+export { ScopeBusyError, checkTool, describeOutcome, dispatchTool, guardTool, httpStatusFor, onceProcessor, toAnthropicTool, toOpenAITool, webhookOnce };
+export type { GuardedTool, GuardedToolSpec, JobLike, JsonSchema, OnceProcessorOptions, SkipReason, Skipped, ToolDefinition, ToolOutcome, WebhookOnceInput, WebhookOnceResponse };