octoflow-core 1.0.0

package/dist/utils/api-keys.d.ts

@@ -0,0 +1,21 @@
+import type { AuthStore } from '../auth/types.js';
+import type { BackendName } from '../domain/core-client.js';
+export declare const API_KEY_ENV: Partial<Record<BackendName, string>>;
+/** Maps backend names to their base-URL config key used by the backend factory. */
+export declare const HOST_CONFIG_KEY: Partial<Record<BackendName, string>>;
+/**
+ * Backend → OAuth provider mapping. OAuth tokens from these providers can
+ * serve as API keys for the corresponding backends when no explicit key is set.
+ */
+export declare const OAUTH_PROVIDER_MAP: Partial<Record<BackendName, string>>;
+/**
+ * Maps CLI backends to the env var + OAuth provider they need.
+ * When spawning a CLI process, an OAuth token is injected as this env var
+ * so the CLI picks it up natively (e.g. claude-code-cli reads ANTHROPIC_API_KEY).
+ */
+export declare const CLI_OAUTH_ENV_MAP: Partial<Record<BackendName, {
+    envVar: string;
+    provider: string;
+}>>;
+export declare function getApiKey(name: BackendName, apiKeys: Partial<Record<BackendName, string>>, authStore?: AuthStore): string | undefined;
+//# sourceMappingURL=api-keys.d.ts.map

package/dist/utils/api-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-keys.d.ts","sourceRoot":"","sources":["../../src/utils/api-keys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAE5D,eAAO,MAAM,WAAW,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAS5D,CAAC;AAEF,mFAAmF;AACnF,eAAO,MAAM,eAAe,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAIhE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAKnE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,OAAO,CACrC,MAAM,CAAC,WAAW,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAK1D,CAAC;AAEF,wBAAgB,SAAS,CACvB,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,EAC7C,SAAS,CAAC,EAAE,SAAS,GACpB,MAAM,GAAG,SAAS,CAepB"}

package/dist/utils/api-keys.js

@@ -0,0 +1,47 @@
+const API_KEY_ENV = {
+  "anthropic-api": "ANTHROPIC_API_KEY",
+  "gemini-api": "GEMINI_API_KEY",
+  "gemini-cli": "GEMINI_API_KEY",
+  ollama: "OLLAMA_API_KEY",
+  "openai-api": "OPENAI_API_KEY",
+  "vercel-ai:anthropic": "ANTHROPIC_API_KEY",
+  "vercel-ai:openai": "OPENAI_API_KEY",
+  "vercel-ai:google": "GEMINI_API_KEY"
+};
+const HOST_CONFIG_KEY = {
+  "anthropic-api": "ANTHROPIC_BASE_URL",
+  "gemini-api": "GEMINI_BASE_URL",
+  "openai-api": "OPENAI_BASE_URL"
+};
+const OAUTH_PROVIDER_MAP = {
+  "anthropic-api": "anthropic",
+  "openai-api": "openai",
+  "vercel-ai:anthropic": "anthropic",
+  "vercel-ai:openai": "openai"
+};
+const CLI_OAUTH_ENV_MAP = {
+  "claude-code-cli": { envVar: "ANTHROPIC_API_KEY", provider: "anthropic" },
+  "codex-cli": { envVar: "OPENAI_API_KEY", provider: "openai" },
+  "gemini-cli": { envVar: "GEMINI_API_KEY", provider: "google" }
+};
+function getApiKey(name, apiKeys, authStore) {
+  if (apiKeys[name]) return apiKeys[name];
+  const envKey = API_KEY_ENV[name];
+  if (envKey && process.env[envKey]) return process.env[envKey];
+  if (authStore) {
+    const provider = OAUTH_PROVIDER_MAP[name];
+    if (provider) {
+      const token = authStore.getTokenSync(provider);
+      if (token?.accessToken) return token.accessToken;
+    }
+  }
+  return void 0;
+}
+export {
+  API_KEY_ENV,
+  CLI_OAUTH_ENV_MAP,
+  HOST_CONFIG_KEY,
+  OAUTH_PROVIDER_MAP,
+  getApiKey
+};
+//# sourceMappingURL=api-keys.js.map

package/dist/utils/api-keys.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/api-keys.ts"],
+  "sourcesContent": ["import type { AuthStore } from '../auth/types.js';\nimport type { BackendName } from '../domain/core-client.js';\n\nexport const API_KEY_ENV: Partial<Record<BackendName, string>> = {\n  'anthropic-api': 'ANTHROPIC_API_KEY',\n  'gemini-api': 'GEMINI_API_KEY',\n  'gemini-cli': 'GEMINI_API_KEY',\n  ollama: 'OLLAMA_API_KEY',\n  'openai-api': 'OPENAI_API_KEY',\n  'vercel-ai:anthropic': 'ANTHROPIC_API_KEY',\n  'vercel-ai:openai': 'OPENAI_API_KEY',\n  'vercel-ai:google': 'GEMINI_API_KEY',\n};\n\n/** Maps backend names to their base-URL config key used by the backend factory. */\nexport const HOST_CONFIG_KEY: Partial<Record<BackendName, string>> = {\n  'anthropic-api': 'ANTHROPIC_BASE_URL',\n  'gemini-api': 'GEMINI_BASE_URL',\n  'openai-api': 'OPENAI_BASE_URL',\n};\n\n/**\n * Backend \u2192 OAuth provider mapping. OAuth tokens from these providers can\n * serve as API keys for the corresponding backends when no explicit key is set.\n */\nexport const OAUTH_PROVIDER_MAP: Partial<Record<BackendName, string>> = {\n  'anthropic-api': 'anthropic',\n  'openai-api': 'openai',\n  'vercel-ai:anthropic': 'anthropic',\n  'vercel-ai:openai': 'openai',\n};\n\n/**\n * Maps CLI backends to the env var + OAuth provider they need.\n * When spawning a CLI process, an OAuth token is injected as this env var\n * so the CLI picks it up natively (e.g. claude-code-cli reads ANTHROPIC_API_KEY).\n */\nexport const CLI_OAUTH_ENV_MAP: Partial<\n  Record<BackendName, { envVar: string; provider: string }>\n> = {\n  'claude-code-cli': { envVar: 'ANTHROPIC_API_KEY', provider: 'anthropic' },\n  'codex-cli': { envVar: 'OPENAI_API_KEY', provider: 'openai' },\n  'gemini-cli': { envVar: 'GEMINI_API_KEY', provider: 'google' },\n};\n\nexport function getApiKey(\n  name: BackendName,\n  apiKeys: Partial<Record<BackendName, string>>,\n  authStore?: AuthStore\n): string | undefined {\n  if (apiKeys[name]) return apiKeys[name];\n\n  const envKey = API_KEY_ENV[name];\n  if (envKey && process.env[envKey]) return process.env[envKey];\n\n  if (authStore) {\n    const provider = OAUTH_PROVIDER_MAP[name];\n    if (provider) {\n      const token = authStore.getTokenSync(provider);\n      if (token?.accessToken) return token.accessToken;\n    }\n  }\n\n  return undefined;\n}\n"],
+  "mappings": "AAGO,MAAM,cAAoD;AAAA,EAC/D,iBAAiB;AAAA,EACjB,cAAc;AAAA,EACd,cAAc;AAAA,EACd,QAAQ;AAAA,EACR,cAAc;AAAA,EACd,uBAAuB;AAAA,EACvB,oBAAoB;AAAA,EACpB,oBAAoB;AACtB;AAGO,MAAM,kBAAwD;AAAA,EACnE,iBAAiB;AAAA,EACjB,cAAc;AAAA,EACd,cAAc;AAChB;AAMO,MAAM,qBAA2D;AAAA,EACtE,iBAAiB;AAAA,EACjB,cAAc;AAAA,EACd,uBAAuB;AAAA,EACvB,oBAAoB;AACtB;AAOO,MAAM,oBAET;AAAA,EACF,mBAAmB,EAAE,QAAQ,qBAAqB,UAAU,YAAY;AAAA,EACxE,aAAa,EAAE,QAAQ,kBAAkB,UAAU,SAAS;AAAA,EAC5D,cAAc,EAAE,QAAQ,kBAAkB,UAAU,SAAS;AAC/D;AAEO,SAAS,UACd,MACA,SACA,WACoB;AACpB,MAAI,QAAQ,IAAI,EAAG,QAAO,QAAQ,IAAI;AAEtC,QAAM,SAAS,YAAY,IAAI;AAC/B,MAAI,UAAU,QAAQ,IAAI,MAAM,EAAG,QAAO,QAAQ,IAAI,MAAM;AAE5D,MAAI,WAAW;AACb,UAAM,WAAW,mBAAmB,IAAI;AACxC,QAAI,UAAU;AACZ,YAAM,QAAQ,UAAU,aAAa,QAAQ;AAC7C,UAAI,OAAO,YAAa,QAAO,MAAM;AAAA,IACvC;AAAA,EACF;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/utils/assert-never.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Exhaustiveness helper for discriminated-union `switch` blocks.
+ *
+ * Call as the `default:` branch (or after a `switch`) so TypeScript verifies
+ * every variant is handled at compile time — adding a new variant to the union
+ * becomes a type error at every call site instead of a silent fall-through.
+ *
+ * At runtime, it throws if somehow reached (e.g. an unchecked JSON payload).
+ */
+export declare function assertNever(value: never, ctx?: string): never;
+//# sourceMappingURL=assert-never.d.ts.map

package/dist/utils/assert-never.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert-never.d.ts","sourceRoot":"","sources":["../../src/utils/assert-never.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,CAG7D"}

package/dist/utils/assert-never.js

@@ -0,0 +1,8 @@
+function assertNever(value, ctx) {
+  const suffix = ctx ? ` in ${ctx}` : "";
+  throw new Error(`Unhandled discriminant${suffix}: ${String(value)}`);
+}
+export {
+  assertNever
+};
+//# sourceMappingURL=assert-never.js.map

package/dist/utils/assert-never.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/assert-never.ts"],
+  "sourcesContent": ["/**\n * Exhaustiveness helper for discriminated-union `switch` blocks.\n *\n * Call as the `default:` branch (or after a `switch`) so TypeScript verifies\n * every variant is handled at compile time \u2014 adding a new variant to the union\n * becomes a type error at every call site instead of a silent fall-through.\n *\n * At runtime, it throws if somehow reached (e.g. an unchecked JSON payload).\n */\nexport function assertNever(value: never, ctx?: string): never {\n  const suffix = ctx ? ` in ${ctx}` : '';\n  throw new Error(`Unhandled discriminant${suffix}: ${String(value)}`);\n}\n"],
+  "mappings": "AASO,SAAS,YAAY,OAAc,KAAqB;AAC7D,QAAM,SAAS,MAAM,OAAO,GAAG,KAAK;AACpC,QAAM,IAAI,MAAM,yBAAyB,MAAM,KAAK,OAAO,KAAK,CAAC,EAAE;AACrE;",
+  "names": []
+}

package/dist/utils/clone.d.ts

@@ -0,0 +1,2 @@
+export declare function cloneValue<T>(value: T): T;
+//# sourceMappingURL=clone.d.ts.map

package/dist/utils/clone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone.d.ts","sourceRoot":"","sources":["../../src/utils/clone.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAKzC"}

package/dist/utils/clone.js

@@ -0,0 +1,10 @@
+function cloneValue(value) {
+  if (typeof structuredClone === "function") {
+    return structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+export {
+  cloneValue
+};
+//# sourceMappingURL=clone.js.map

package/dist/utils/clone.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/clone.ts"],
+  "sourcesContent": ["export function cloneValue<T>(value: T): T {\n  if (typeof structuredClone === 'function') {\n    return structuredClone(value);\n  }\n  return JSON.parse(JSON.stringify(value)) as T;\n}\n"],
+  "mappings": "AAAO,SAAS,WAAc,OAAa;AACzC,MAAI,OAAO,oBAAoB,YAAY;AACzC,WAAO,gBAAgB,KAAK;AAAA,EAC9B;AACA,SAAO,KAAK,MAAM,KAAK,UAAU,KAAK,CAAC;AACzC;",
+  "names": []
+}

package/dist/utils/extract-text.d.ts

@@ -0,0 +1,11 @@
+import type { BridgeSendResult } from '../domain/bridge-api.js';
+import type { Message, Task } from '../domain/core-task.js';
+export declare function extractTextFromTask(task: Task): string;
+export declare function extractText(result: BridgeSendResult): string;
+/**
+ * Extracts the plain-text body from a run `message` parameter.
+ * Handles both the `string` shorthand and the structured `Message` form.
+ * Uses the `kind` discriminant for type-safe narrowing — not `'text' in p`.
+ */
+export declare function extractRunMessageText(message: Message | string): string;
+//# sourceMappingURL=extract-text.d.ts.map

package/dist/utils/extract-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-text.d.ts","sourceRoot":"","sources":["../../src/utils/extract-text.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,OAAO,EAAQ,IAAI,EAAY,MAAM,wBAAwB,CAAC;AAE5E,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAgBtD;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAQ5D;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAMvE"}

package/dist/utils/extract-text.js

@@ -0,0 +1,27 @@
+function extractTextFromTask(task) {
+  const artifact = task.artifacts?.find(
+    (a) => a.artifactId === "assistant-response"
+  );
+  if (artifact) {
+    return artifact.parts.filter((p) => p.kind === "text").map((p) => p.text).join("");
+  }
+  const msg = task.status.message;
+  if (!msg) return "";
+  return msg.parts.filter((p) => p.kind === "text").map((p) => p.text).join("");
+}
+function extractText(result) {
+  if (result.kind === "message") {
+    return result.message.parts.filter((p) => p.kind === "text").map((p) => p.text).join("");
+  }
+  return extractTextFromTask(result.task);
+}
+function extractRunMessageText(message) {
+  if (typeof message === "string") return message;
+  return message.parts.filter((p) => p.kind === "text").map((p) => p.text).join("");
+}
+export {
+  extractRunMessageText,
+  extractText,
+  extractTextFromTask
+};
+//# sourceMappingURL=extract-text.js.map

package/dist/utils/extract-text.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/extract-text.ts"],
+  "sourcesContent": ["import type { BridgeSendResult } from '../domain/bridge-api.js';\nimport type { Message, Part, Task, TextPart } from '../domain/core-task.js';\n\nexport function extractTextFromTask(task: Task): string {\n  const artifact = task.artifacts?.find(\n    (a) => a.artifactId === 'assistant-response'\n  );\n  if (artifact) {\n    return artifact.parts\n      .filter((p): p is Extract<Part, { kind: 'text' }> => p.kind === 'text')\n      .map((p) => p.text)\n      .join('');\n  }\n  const msg = task.status.message;\n  if (!msg) return '';\n  return msg.parts\n    .filter((p): p is Extract<Part, { kind: 'text' }> => p.kind === 'text')\n    .map((p) => p.text)\n    .join('');\n}\n\nexport function extractText(result: BridgeSendResult): string {\n  if (result.kind === 'message') {\n    return result.message.parts\n      .filter((p): p is Extract<Part, { kind: 'text' }> => p.kind === 'text')\n      .map((p) => p.text)\n      .join('');\n  }\n  return extractTextFromTask(result.task);\n}\n\n/**\n * Extracts the plain-text body from a run `message` parameter.\n * Handles both the `string` shorthand and the structured `Message` form.\n * Uses the `kind` discriminant for type-safe narrowing \u2014 not `'text' in p`.\n */\nexport function extractRunMessageText(message: Message | string): string {\n  if (typeof message === 'string') return message;\n  return message.parts\n    .filter((p): p is TextPart => p.kind === 'text')\n    .map((p) => p.text)\n    .join('');\n}\n"],
+  "mappings": "AAGO,SAAS,oBAAoB,MAAoB;AACtD,QAAM,WAAW,KAAK,WAAW;AAAA,IAC/B,CAAC,MAAM,EAAE,eAAe;AAAA,EAC1B;AACA,MAAI,UAAU;AACZ,WAAO,SAAS,MACb,OAAO,CAAC,MAA4C,EAAE,SAAS,MAAM,EACrE,IAAI,CAAC,MAAM,EAAE,IAAI,EACjB,KAAK,EAAE;AAAA,EACZ;AACA,QAAM,MAAM,KAAK,OAAO;AACxB,MAAI,CAAC,IAAK,QAAO;AACjB,SAAO,IAAI,MACR,OAAO,CAAC,MAA4C,EAAE,SAAS,MAAM,EACrE,IAAI,CAAC,MAAM,EAAE,IAAI,EACjB,KAAK,EAAE;AACZ;AAEO,SAAS,YAAY,QAAkC;AAC5D,MAAI,OAAO,SAAS,WAAW;AAC7B,WAAO,OAAO,QAAQ,MACnB,OAAO,CAAC,MAA4C,EAAE,SAAS,MAAM,EACrE,IAAI,CAAC,MAAM,EAAE,IAAI,EACjB,KAAK,EAAE;AAAA,EACZ;AACA,SAAO,oBAAoB,OAAO,IAAI;AACxC;AAOO,SAAS,sBAAsB,SAAmC;AACvE,MAAI,OAAO,YAAY,SAAU,QAAO;AACxC,SAAO,QAAQ,MACZ,OAAO,CAAC,MAAqB,EAAE,SAAS,MAAM,EAC9C,IAAI,CAAC,MAAM,EAAE,IAAI,EACjB,KAAK,EAAE;AACZ;",
+  "names": []
+}

package/dist/utils/messages.d.ts

@@ -0,0 +1,29 @@
+import type { BridgeSendMessageParams } from '../domain/bridge-api.js';
+import type { Message, MessageMetadata, Part } from '../domain/core-task.js';
+/** Create a text part. */
+export declare function textPart(text: string): Part;
+/**
+ * Create a typed Message with sensible defaults.
+ *
+ * By default, `metadata.timestamp` is auto-stamped to the current ISO-8601
+ * wall time so history strategies (e.g. `{ kind: 'since' }`) can filter by
+ * age. Pass `stamp: false` to suppress — use this on replay/resume paths where
+ * the original timestamp must be preserved.
+ */
+export declare function createMessage(input: {
+    contextId?: string;
+    messageId?: string;
+    metadata?: MessageMetadata;
+    parts: Part[];
+    role: Message['role'];
+    taskId?: string;
+    /** Set `false` to suppress auto-stamping. Defaults to `true`. */
+    stamp?: boolean;
+}): Message;
+/**
+ * Normalise the polymorphic `message` field of BridgeSendMessageParams to a
+ * full Message. User messages arrive with the caller's own clock — `stamp` is
+ * suppressed so we never overwrite an explicit `metadata.timestamp`.
+ */
+export declare function normalizeUserMessage(input: BridgeSendMessageParams['message'], contextId?: string, taskId?: string): Message;
+//# sourceMappingURL=messages.d.ts.map

package/dist/utils/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/utils/messages.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AACvE,OAAO,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAE7E,0BAA0B;AAC1B,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAE3C;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iEAAiE;IACjE,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,OAAO,CAgBV;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,uBAAuB,CAAC,SAAS,CAAC,EACzC,SAAS,CAAC,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAqBT"}

package/dist/utils/messages.js

@@ -0,0 +1,43 @@
+import crypto from "node:crypto";
+function textPart(text) {
+  return { kind: "text", text };
+}
+function createMessage(input) {
+  const stamp = input.stamp !== false;
+  const metadata = stamp && !input.metadata?.timestamp ? { ...input.metadata, timestamp: (/* @__PURE__ */ new Date()).toISOString() } : input.metadata;
+  return {
+    kind: "message",
+    messageId: input.messageId ?? crypto.randomUUID(),
+    role: input.role,
+    parts: input.parts,
+    contextId: input.contextId,
+    taskId: input.taskId,
+    metadata
+  };
+}
+function normalizeUserMessage(input, contextId, taskId) {
+  if (typeof input === "string") {
+    return createMessage({
+      role: "user",
+      parts: [textPart(input)],
+      contextId,
+      taskId,
+      stamp: false
+    });
+  }
+  if (input.role !== "user") {
+    throw new Error("Bridge.sendMessage() requires a user message");
+  }
+  return {
+    ...input,
+    contextId: input.contextId ?? contextId,
+    taskId: input.taskId ?? taskId,
+    messageId: input.messageId ?? crypto.randomUUID()
+  };
+}
+export {
+  createMessage,
+  normalizeUserMessage,
+  textPart
+};
+//# sourceMappingURL=messages.js.map

package/dist/utils/messages.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/messages.ts"],
+  "sourcesContent": ["import crypto from 'node:crypto';\n\nimport type { BridgeSendMessageParams } from '../domain/bridge-api.js';\nimport type { Message, MessageMetadata, Part } from '../domain/core-task.js';\n\n/** Create a text part. */\nexport function textPart(text: string): Part {\n  return { kind: 'text', text };\n}\n\n/**\n * Create a typed Message with sensible defaults.\n *\n * By default, `metadata.timestamp` is auto-stamped to the current ISO-8601\n * wall time so history strategies (e.g. `{ kind: 'since' }`) can filter by\n * age. Pass `stamp: false` to suppress \u2014 use this on replay/resume paths where\n * the original timestamp must be preserved.\n */\nexport function createMessage(input: {\n  contextId?: string;\n  messageId?: string;\n  metadata?: MessageMetadata;\n  parts: Part[];\n  role: Message['role'];\n  taskId?: string;\n  /** Set `false` to suppress auto-stamping. Defaults to `true`. */\n  stamp?: boolean;\n}): Message {\n  const stamp = input.stamp !== false;\n  const metadata: MessageMetadata | undefined =\n    stamp && !input.metadata?.timestamp\n      ? { ...input.metadata, timestamp: new Date().toISOString() }\n      : input.metadata;\n\n  return {\n    kind: 'message',\n    messageId: input.messageId ?? crypto.randomUUID(),\n    role: input.role,\n    parts: input.parts,\n    contextId: input.contextId,\n    taskId: input.taskId,\n    metadata,\n  };\n}\n\n/**\n * Normalise the polymorphic `message` field of BridgeSendMessageParams to a\n * full Message. User messages arrive with the caller's own clock \u2014 `stamp` is\n * suppressed so we never overwrite an explicit `metadata.timestamp`.\n */\nexport function normalizeUserMessage(\n  input: BridgeSendMessageParams['message'],\n  contextId?: string,\n  taskId?: string\n): Message {\n  if (typeof input === 'string') {\n    return createMessage({\n      role: 'user',\n      parts: [textPart(input)],\n      contextId,\n      taskId,\n      stamp: false,\n    });\n  }\n\n  if (input.role !== 'user') {\n    throw new Error('Bridge.sendMessage() requires a user message');\n  }\n\n  return {\n    ...input,\n    contextId: input.contextId ?? contextId,\n    taskId: input.taskId ?? taskId,\n    messageId: input.messageId ?? crypto.randomUUID(),\n  };\n}\n"],
+  "mappings": "AAAA,OAAO,YAAY;AAMZ,SAAS,SAAS,MAAoB;AAC3C,SAAO,EAAE,MAAM,QAAQ,KAAK;AAC9B;AAUO,SAAS,cAAc,OASlB;AACV,QAAM,QAAQ,MAAM,UAAU;AAC9B,QAAM,WACJ,SAAS,CAAC,MAAM,UAAU,YACtB,EAAE,GAAG,MAAM,UAAU,YAAW,oBAAI,KAAK,GAAE,YAAY,EAAE,IACzD,MAAM;AAEZ,SAAO;AAAA,IACL,MAAM;AAAA,IACN,WAAW,MAAM,aAAa,OAAO,WAAW;AAAA,IAChD,MAAM,MAAM;AAAA,IACZ,OAAO,MAAM;AAAA,IACb,WAAW,MAAM;AAAA,IACjB,QAAQ,MAAM;AAAA,IACd;AAAA,EACF;AACF;AAOO,SAAS,qBACd,OACA,WACA,QACS;AACT,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO,cAAc;AAAA,MACnB,MAAM;AAAA,MACN,OAAO,CAAC,SAAS,KAAK,CAAC;AAAA,MACvB;AAAA,MACA;AAAA,MACA,OAAO;AAAA,IACT,CAAC;AAAA,EACH;AAEA,MAAI,MAAM,SAAS,QAAQ;AACzB,UAAM,IAAI,MAAM,8CAA8C;AAAA,EAChE;AAEA,SAAO;AAAA,IACL,GAAG;AAAA,IACH,WAAW,MAAM,aAAa;AAAA,IAC9B,QAAQ,MAAM,UAAU;AAAA,IACxB,WAAW,MAAM,aAAa,OAAO,WAAW;AAAA,EAClD;AACF;",
+  "names": []
+}

package/dist/utils/metadata.d.ts

@@ -0,0 +1,2 @@
+export declare function mergeMetadata(left: Record<string, unknown> | undefined, right: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
+//# sourceMappingURL=metadata.d.ts.map

package/dist/utils/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../src/utils/metadata.ts"],"names":[],"mappings":"AAAA,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EACzC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GACzC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAOrC"}

package/dist/utils/metadata.js

@@ -0,0 +1,12 @@
+function mergeMetadata(left, right) {
+  if (!left && !right) return void 0;
+  const merged = { ...left ?? {}, ...right ?? {} };
+  if (left?.bridge && right?.bridge) {
+    merged.bridge = { ...left.bridge, ...right.bridge };
+  }
+  return merged;
+}
+export {
+  mergeMetadata
+};
+//# sourceMappingURL=metadata.js.map

package/dist/utils/metadata.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/metadata.ts"],
+  "sourcesContent": ["export function mergeMetadata(\n  left: Record<string, unknown> | undefined,\n  right: Record<string, unknown> | undefined\n): Record<string, unknown> | undefined {\n  if (!left && !right) return undefined;\n  const merged = { ...(left ?? {}), ...(right ?? {}) };\n  if (left?.bridge && right?.bridge) {\n    merged.bridge = { ...left.bridge, ...right.bridge };\n  }\n  return merged;\n}\n"],
+  "mappings": "AAAO,SAAS,cACd,MACA,OACqC;AACrC,MAAI,CAAC,QAAQ,CAAC,MAAO,QAAO;AAC5B,QAAM,SAAS,EAAE,GAAI,QAAQ,CAAC,GAAI,GAAI,SAAS,CAAC,EAAG;AACnD,MAAI,MAAM,UAAU,OAAO,QAAQ;AACjC,WAAO,SAAS,EAAE,GAAG,KAAK,QAAQ,GAAG,MAAM,OAAO;AAAA,EACpD;AACA,SAAO;AACT;",
+  "names": []
+}

package/dist/utils/octoflow-home.d.ts

@@ -0,0 +1,18 @@
+export declare const OCTOFLOW_HOME_ENV = "OCTOFLOW_HOME";
+export type OctoFlowDbName = 'approvals' | 'brain' | 'memory' | 'session-memory' | 'sessions' | 'tasks';
+export interface OctoFlowHomeOptions {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+}
+export declare function expandUserPath(value: string, options?: OctoFlowHomeOptions): string;
+export declare function resolveUserPath(value: string, options?: OctoFlowHomeOptions): string;
+export declare function getOctoFlowHome(options?: OctoFlowHomeOptions): string;
+export declare function getOctoFlowPath(segments?: string[], options?: OctoFlowHomeOptions): string;
+export declare function getOctoFlowConfigPath(options?: OctoFlowHomeOptions): string;
+export declare function getOctoFlowMcpConfigPath(options?: OctoFlowHomeOptions): string;
+export declare function getOctoFlowSkillsDir(options?: OctoFlowHomeOptions): string;
+export declare function getOctoFlowAuthDir(options?: OctoFlowHomeOptions): string;
+export declare function getOctoFlowDbDir(options?: OctoFlowHomeOptions): string;
+export declare function getOctoFlowDbPath(name: OctoFlowDbName, options?: OctoFlowHomeOptions): string;
+//# sourceMappingURL=octoflow-home.d.ts.map

package/dist/utils/octoflow-home.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"octoflow-home.d.ts","sourceRoot":"","sources":["../../src/utils/octoflow-home.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB,kBAAkB,CAAC;AAEjD,MAAM,MAAM,cAAc,GACtB,WAAW,GACX,OAAO,GACP,QAAQ,GACR,gBAAgB,GAChB,UAAU,GACV,OAAO,CAAC;AAEZ,MAAM,WAAW,mBAAmB;IAClC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAWD,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,mBAAwB,GAChC,MAAM,CAOR;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,mBAAwB,GAChC,MAAM,CAGR;AAED,wBAAgB,eAAe,CAAC,OAAO,GAAE,mBAAwB,GAAG,MAAM,CAMzE;AAED,wBAAgB,eAAe,CAC7B,QAAQ,GAAE,MAAM,EAAO,EACvB,OAAO,GAAE,mBAAwB,GAChC,MAAM,CAER;AAED,wBAAgB,qBAAqB,CACnC,OAAO,GAAE,mBAAwB,GAChC,MAAM,CAER;AAED,wBAAgB,wBAAwB,CACtC,OAAO,GAAE,mBAAwB,GAChC,MAAM,CAER;AAED,wBAAgB,oBAAoB,CAClC,OAAO,GAAE,mBAAwB,GAChC,MAAM,CAER;AAED,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,mBAAwB,GAAG,MAAM,CAE5E;AAED,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,mBAAwB,GAAG,MAAM,CAE1E;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,cAAc,EACpB,OAAO,GAAE,mBAAwB,GAChC,MAAM,CAER"}

package/dist/utils/octoflow-home.js

@@ -0,0 +1,65 @@
+import { homedir } from "node:os";
+import path from "node:path";
+const OCTOFLOW_HOME_ENV = "OCTOFLOW_HOME";
+const DB_FILES = {
+  approvals: "approvals.sqlite",
+  brain: "brain.sqlite",
+  memory: "memory.sqlite",
+  "session-memory": "session-memory.sqlite",
+  sessions: "sessions.sqlite",
+  tasks: "tasks.sqlite"
+};
+function expandUserPath(value, options = {}) {
+  const home = options.home ?? homedir();
+  if (value === "~") return home;
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return path.join(home, value.slice(2));
+  }
+  return value;
+}
+function resolveUserPath(value, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  return path.resolve(cwd, expandUserPath(value, options));
+}
+function getOctoFlowHome(options = {}) {
+  const configured = (options.env ?? process.env)[OCTOFLOW_HOME_ENV];
+  if (configured && configured.trim().length > 0) {
+    return resolveUserPath(configured, options);
+  }
+  return path.join(options.home ?? homedir(), ".octoflow");
+}
+function getOctoFlowPath(segments = [], options = {}) {
+  return path.join(getOctoFlowHome(options), ...segments);
+}
+function getOctoFlowConfigPath(options = {}) {
+  return getOctoFlowPath(["config.json"], options);
+}
+function getOctoFlowMcpConfigPath(options = {}) {
+  return getOctoFlowPath(["mcp.json"], options);
+}
+function getOctoFlowSkillsDir(options = {}) {
+  return getOctoFlowPath(["skills"], options);
+}
+function getOctoFlowAuthDir(options = {}) {
+  return getOctoFlowPath(["auth"], options);
+}
+function getOctoFlowDbDir(options = {}) {
+  return getOctoFlowPath(["db"], options);
+}
+function getOctoFlowDbPath(name, options = {}) {
+  return path.join(getOctoFlowDbDir(options), DB_FILES[name]);
+}
+export {
+  OCTOFLOW_HOME_ENV,
+  expandUserPath,
+  getOctoFlowAuthDir,
+  getOctoFlowConfigPath,
+  getOctoFlowDbDir,
+  getOctoFlowDbPath,
+  getOctoFlowHome,
+  getOctoFlowMcpConfigPath,
+  getOctoFlowPath,
+  getOctoFlowSkillsDir,
+  resolveUserPath
+};
+//# sourceMappingURL=octoflow-home.js.map

package/dist/utils/octoflow-home.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/octoflow-home.ts"],
+  "sourcesContent": ["import { homedir } from 'node:os';\nimport path from 'node:path';\n\nexport const OCTOFLOW_HOME_ENV = 'OCTOFLOW_HOME';\n\nexport type OctoFlowDbName =\n  | 'approvals'\n  | 'brain'\n  | 'memory'\n  | 'session-memory'\n  | 'sessions'\n  | 'tasks';\n\nexport interface OctoFlowHomeOptions {\n  cwd?: string;\n  env?: NodeJS.ProcessEnv;\n  home?: string;\n}\n\nconst DB_FILES: Record<OctoFlowDbName, string> = {\n  approvals: 'approvals.sqlite',\n  brain: 'brain.sqlite',\n  memory: 'memory.sqlite',\n  'session-memory': 'session-memory.sqlite',\n  sessions: 'sessions.sqlite',\n  tasks: 'tasks.sqlite',\n};\n\nexport function expandUserPath(\n  value: string,\n  options: OctoFlowHomeOptions = {}\n): string {\n  const home = options.home ?? homedir();\n  if (value === '~') return home;\n  if (value.startsWith('~/') || value.startsWith('~\\\\')) {\n    return path.join(home, value.slice(2));\n  }\n  return value;\n}\n\nexport function resolveUserPath(\n  value: string,\n  options: OctoFlowHomeOptions = {}\n): string {\n  const cwd = options.cwd ?? process.cwd();\n  return path.resolve(cwd, expandUserPath(value, options));\n}\n\nexport function getOctoFlowHome(options: OctoFlowHomeOptions = {}): string {\n  const configured = (options.env ?? process.env)[OCTOFLOW_HOME_ENV];\n  if (configured && configured.trim().length > 0) {\n    return resolveUserPath(configured, options);\n  }\n  return path.join(options.home ?? homedir(), '.octoflow');\n}\n\nexport function getOctoFlowPath(\n  segments: string[] = [],\n  options: OctoFlowHomeOptions = {}\n): string {\n  return path.join(getOctoFlowHome(options), ...segments);\n}\n\nexport function getOctoFlowConfigPath(\n  options: OctoFlowHomeOptions = {}\n): string {\n  return getOctoFlowPath(['config.json'], options);\n}\n\nexport function getOctoFlowMcpConfigPath(\n  options: OctoFlowHomeOptions = {}\n): string {\n  return getOctoFlowPath(['mcp.json'], options);\n}\n\nexport function getOctoFlowSkillsDir(\n  options: OctoFlowHomeOptions = {}\n): string {\n  return getOctoFlowPath(['skills'], options);\n}\n\nexport function getOctoFlowAuthDir(options: OctoFlowHomeOptions = {}): string {\n  return getOctoFlowPath(['auth'], options);\n}\n\nexport function getOctoFlowDbDir(options: OctoFlowHomeOptions = {}): string {\n  return getOctoFlowPath(['db'], options);\n}\n\nexport function getOctoFlowDbPath(\n  name: OctoFlowDbName,\n  options: OctoFlowHomeOptions = {}\n): string {\n  return path.join(getOctoFlowDbDir(options), DB_FILES[name]);\n}\n"],
+  "mappings": "AAAA,SAAS,eAAe;AACxB,OAAO,UAAU;AAEV,MAAM,oBAAoB;AAgBjC,MAAM,WAA2C;AAAA,EAC/C,WAAW;AAAA,EACX,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,kBAAkB;AAAA,EAClB,UAAU;AAAA,EACV,OAAO;AACT;AAEO,SAAS,eACd,OACA,UAA+B,CAAC,GACxB;AACR,QAAM,OAAO,QAAQ,QAAQ,QAAQ;AACrC,MAAI,UAAU,IAAK,QAAO;AAC1B,MAAI,MAAM,WAAW,IAAI,KAAK,MAAM,WAAW,KAAK,GAAG;AACrD,WAAO,KAAK,KAAK,MAAM,MAAM,MAAM,CAAC,CAAC;AAAA,EACvC;AACA,SAAO;AACT;AAEO,SAAS,gBACd,OACA,UAA+B,CAAC,GACxB;AACR,QAAM,MAAM,QAAQ,OAAO,QAAQ,IAAI;AACvC,SAAO,KAAK,QAAQ,KAAK,eAAe,OAAO,OAAO,CAAC;AACzD;AAEO,SAAS,gBAAgB,UAA+B,CAAC,GAAW;AACzE,QAAM,cAAc,QAAQ,OAAO,QAAQ,KAAK,iBAAiB;AACjE,MAAI,cAAc,WAAW,KAAK,EAAE,SAAS,GAAG;AAC9C,WAAO,gBAAgB,YAAY,OAAO;AAAA,EAC5C;AACA,SAAO,KAAK,KAAK,QAAQ,QAAQ,QAAQ,GAAG,WAAW;AACzD;AAEO,SAAS,gBACd,WAAqB,CAAC,GACtB,UAA+B,CAAC,GACxB;AACR,SAAO,KAAK,KAAK,gBAAgB,OAAO,GAAG,GAAG,QAAQ;AACxD;AAEO,SAAS,sBACd,UAA+B,CAAC,GACxB;AACR,SAAO,gBAAgB,CAAC,aAAa,GAAG,OAAO;AACjD;AAEO,SAAS,yBACd,UAA+B,CAAC,GACxB;AACR,SAAO,gBAAgB,CAAC,UAAU,GAAG,OAAO;AAC9C;AAEO,SAAS,qBACd,UAA+B,CAAC,GACxB;AACR,SAAO,gBAAgB,CAAC,QAAQ,GAAG,OAAO;AAC5C;AAEO,SAAS,mBAAmB,UAA+B,CAAC,GAAW;AAC5E,SAAO,gBAAgB,CAAC,MAAM,GAAG,OAAO;AAC1C;AAEO,SAAS,iBAAiB,UAA+B,CAAC,GAAW;AAC1E,SAAO,gBAAgB,CAAC,IAAI,GAAG,OAAO;AACxC;AAEO,SAAS,kBACd,MACA,UAA+B,CAAC,GACxB;AACR,SAAO,KAAK,KAAK,iBAAiB,OAAO,GAAG,SAAS,IAAI,CAAC;AAC5D;",
+  "names": []
+}

package/dist/utils/operation-info.d.ts

@@ -0,0 +1,15 @@
+import type { BackendName } from '../domain/core-client.js';
+import type { ErrorInfo, FallbackInfo, RetryInfo } from '../domain/core-task.js';
+export declare function normalizeOperationError(error: unknown): ErrorInfo['error'];
+export declare function toErrorInfo(phase: ErrorInfo['phase'], backend: BackendName | null, error: unknown): ErrorInfo;
+export declare function retryDelayMs(attempt: number, baseMs?: number): number;
+export declare function toRetryInfo(backend: BackendName | null, error: unknown, attempt: number, maxRetries: number, baseMs?: number): RetryInfo;
+export declare function toFallbackInfo(input: {
+    attempt: number;
+    error: unknown;
+    fromBackend: BackendName | null;
+    maxBackends: number;
+    phase: ErrorInfo['phase'];
+    toBackend: BackendName;
+}): FallbackInfo;
+//# sourceMappingURL=operation-info.d.ts.map

package/dist/utils/operation-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation-info.d.ts","sourceRoot":"","sources":["../../src/utils/operation-info.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EACV,SAAS,EACT,YAAY,EACZ,SAAS,EACV,MAAM,wBAAwB,CAAC;AAGhC,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC,CAY1E;AAED,wBAAgB,WAAW,CACzB,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC,EACzB,OAAO,EAAE,WAAW,GAAG,IAAI,EAC3B,KAAK,EAAE,OAAO,GACb,SAAS,CAMX;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,SAAM,GAAG,MAAM,CAElE;AAED,wBAAgB,WAAW,CACzB,OAAO,EAAE,WAAW,GAAG,IAAI,EAC3B,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,MAAM,GACd,SAAS,CAQX;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;IACf,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;IAC1B,SAAS,EAAE,WAAW,CAAC;CACxB,GAAG,YAAY,CASf"}

package/dist/utils/operation-info.js

@@ -0,0 +1,50 @@
+import { sanitizeErrorMessage } from "./sanitize.js";
+function normalizeOperationError(error) {
+  if (error instanceof Error) {
+    return {
+      name: error.name,
+      message: sanitizeErrorMessage(error.message)
+    };
+  }
+  return {
+    name: "Error",
+    message: sanitizeErrorMessage(String(error))
+  };
+}
+function toErrorInfo(phase, backend, error) {
+  return {
+    phase,
+    backend,
+    error: normalizeOperationError(error)
+  };
+}
+function retryDelayMs(attempt, baseMs = 500) {
+  return baseMs * 2 ** Math.max(0, attempt - 1);
+}
+function toRetryInfo(backend, error, attempt, maxRetries, baseMs) {
+  return {
+    attempt,
+    maxRetries,
+    delayMs: retryDelayMs(attempt, baseMs),
+    backend,
+    error: normalizeOperationError(error)
+  };
+}
+function toFallbackInfo(input) {
+  return {
+    attempt: input.attempt,
+    error: normalizeOperationError(input.error),
+    fromBackend: input.fromBackend,
+    maxBackends: input.maxBackends,
+    phase: input.phase,
+    toBackend: input.toBackend
+  };
+}
+export {
+  normalizeOperationError,
+  retryDelayMs,
+  toErrorInfo,
+  toFallbackInfo,
+  toRetryInfo
+};
+//# sourceMappingURL=operation-info.js.map

package/dist/utils/operation-info.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/operation-info.ts"],
+  "sourcesContent": ["import type { BackendName } from '../domain/core-client.js';\nimport type {\n  ErrorInfo,\n  FallbackInfo,\n  RetryInfo,\n} from '../domain/core-task.js';\nimport { sanitizeErrorMessage } from './sanitize.js';\n\nexport function normalizeOperationError(error: unknown): ErrorInfo['error'] {\n  if (error instanceof Error) {\n    return {\n      name: error.name,\n      message: sanitizeErrorMessage(error.message),\n    };\n  }\n\n  return {\n    name: 'Error',\n    message: sanitizeErrorMessage(String(error)),\n  };\n}\n\nexport function toErrorInfo(\n  phase: ErrorInfo['phase'],\n  backend: BackendName | null,\n  error: unknown\n): ErrorInfo {\n  return {\n    phase,\n    backend,\n    error: normalizeOperationError(error),\n  };\n}\n\nexport function retryDelayMs(attempt: number, baseMs = 500): number {\n  return baseMs * 2 ** Math.max(0, attempt - 1);\n}\n\nexport function toRetryInfo(\n  backend: BackendName | null,\n  error: unknown,\n  attempt: number,\n  maxRetries: number,\n  baseMs?: number\n): RetryInfo {\n  return {\n    attempt,\n    maxRetries,\n    delayMs: retryDelayMs(attempt, baseMs),\n    backend,\n    error: normalizeOperationError(error),\n  };\n}\n\nexport function toFallbackInfo(input: {\n  attempt: number;\n  error: unknown;\n  fromBackend: BackendName | null;\n  maxBackends: number;\n  phase: ErrorInfo['phase'];\n  toBackend: BackendName;\n}): FallbackInfo {\n  return {\n    attempt: input.attempt,\n    error: normalizeOperationError(input.error),\n    fromBackend: input.fromBackend,\n    maxBackends: input.maxBackends,\n    phase: input.phase,\n    toBackend: input.toBackend,\n  };\n}\n"],
+  "mappings": "AAMA,SAAS,4BAA4B;AAE9B,SAAS,wBAAwB,OAAoC;AAC1E,MAAI,iBAAiB,OAAO;AAC1B,WAAO;AAAA,MACL,MAAM,MAAM;AAAA,MACZ,SAAS,qBAAqB,MAAM,OAAO;AAAA,IAC7C;AAAA,EACF;AAEA,SAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS,qBAAqB,OAAO,KAAK,CAAC;AAAA,EAC7C;AACF;AAEO,SAAS,YACd,OACA,SACA,OACW;AACX,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,OAAO,wBAAwB,KAAK;AAAA,EACtC;AACF;AAEO,SAAS,aAAa,SAAiB,SAAS,KAAa;AAClE,SAAO,SAAS,KAAK,KAAK,IAAI,GAAG,UAAU,CAAC;AAC9C;AAEO,SAAS,YACd,SACA,OACA,SACA,YACA,QACW;AACX,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,SAAS,aAAa,SAAS,MAAM;AAAA,IACrC;AAAA,IACA,OAAO,wBAAwB,KAAK;AAAA,EACtC;AACF;AAEO,SAAS,eAAe,OAOd;AACf,SAAO;AAAA,IACL,SAAS,MAAM;AAAA,IACf,OAAO,wBAAwB,MAAM,KAAK;AAAA,IAC1C,aAAa,MAAM;AAAA,IACnB,aAAa,MAAM;AAAA,IACnB,OAAO,MAAM;AAAA,IACb,WAAW,MAAM;AAAA,EACnB;AACF;",
+  "names": []
+}

package/dist/utils/rate-limiter.d.ts

@@ -0,0 +1,22 @@
+interface RateLimiterConfig {
+    maxConcurrent?: number | null;
+    maxRequests: number;
+    windowMs: number;
+}
+export interface RateLimitLease {
+    allowed: boolean;
+    limit: number;
+    remaining: number;
+    resetMs: number;
+    retryAfterMs?: number;
+    release(): void;
+}
+export declare class RateLimiter {
+    private readonly config;
+    private readonly buckets;
+    constructor(config: RateLimiterConfig);
+    acquire(key: string): RateLimitLease;
+    private getBucket;
+}
+export {};
+//# sourceMappingURL=rate-limiter.d.ts.map

package/dist/utils/rate-limiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limiter.d.ts","sourceRoot":"","sources":["../../src/utils/rate-limiter.ts"],"names":[],"mappings":"AAKA,UAAU,iBAAiB;IACzB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,qBAAa,WAAW;IAGV,OAAO,CAAC,QAAQ,CAAC,MAAM;IAFnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;gBAEjC,MAAM,EAAE,iBAAiB;IAEtD,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc;IAqEpC,OAAO,CAAC,SAAS;CAWlB"}

package/dist/utils/rate-limiter.js

@@ -0,0 +1,81 @@
+class RateLimiter {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  buckets = /* @__PURE__ */ new Map();
+  acquire(key) {
+    const bucket = this.getBucket(key);
+    const now = Date.now();
+    bucket.timestamps = bucket.timestamps.filter(
+      (timestamp) => now - timestamp < this.config.windowMs
+    );
+    if (bucket.timestamps.length >= this.config.maxRequests) {
+      const earliest2 = bucket.timestamps[0] ?? now;
+      const retryAfterMs = Math.max(0, this.config.windowMs - (now - earliest2));
+      return {
+        allowed: false,
+        limit: this.config.maxRequests,
+        remaining: 0,
+        resetMs: retryAfterMs,
+        retryAfterMs,
+        release: () => void 0
+      };
+    }
+    if (this.config.maxConcurrent != null && this.config.maxConcurrent > 0 && bucket.concurrent >= this.config.maxConcurrent) {
+      const earliest2 = bucket.timestamps[0] ?? now;
+      const retryAfterMs = Math.max(0, this.config.windowMs - (now - earliest2));
+      return {
+        allowed: false,
+        limit: this.config.maxRequests,
+        remaining: Math.max(
+          0,
+          this.config.maxRequests - bucket.timestamps.length
+        ),
+        resetMs: retryAfterMs,
+        retryAfterMs,
+        release: () => void 0
+      };
+    }
+    bucket.timestamps.push(now);
+    bucket.concurrent += 1;
+    const earliest = bucket.timestamps[0] ?? now;
+    const resetMs = Math.max(0, this.config.windowMs - (now - earliest));
+    return {
+      allowed: true,
+      limit: this.config.maxRequests,
+      remaining: Math.max(
+        0,
+        this.config.maxRequests - bucket.timestamps.length
+      ),
+      resetMs,
+      release: () => {
+        const current = this.buckets.get(key);
+        if (!current) return;
+        current.concurrent = Math.max(0, current.concurrent - 1);
+        const activeTimestamps = current.timestamps.filter(
+          (timestamp) => Date.now() - timestamp < this.config.windowMs
+        );
+        current.timestamps = activeTimestamps;
+        if (current.concurrent === 0 && current.timestamps.length === 0) {
+          this.buckets.delete(key);
+        }
+      }
+    };
+  }
+  getBucket(key) {
+    let bucket = this.buckets.get(key);
+    if (!bucket) {
+      bucket = {
+        concurrent: 0,
+        timestamps: []
+      };
+      this.buckets.set(key, bucket);
+    }
+    return bucket;
+  }
+}
+export {
+  RateLimiter
+};
+//# sourceMappingURL=rate-limiter.js.map