@dexto/core 1.7.2 → 1.8.1

package/dist/storage/stores/in-memory.js

@@ -0,0 +1,487 @@
+import "../../chunk-C6A6W6XS.js";
+import { createHash, randomUUID } from "crypto";
+import { cloneInternalMessage, cloneInternalMessages } from "../../context/content-clone.js";
+import { cloneQueuedMessages } from "../../session/queue-clone.js";
+import { splitToolExecutionResult } from "../tool-executions/types.js";
+import { StorageError } from "../errors.js";
+const GLOBAL_SCOPE = "global";
+const DEFAULT_APPROVAL_STATE = {
+  toolPatterns: {},
+  approvedDirectories: []
+};
+const DEFAULT_TOOL_PREFERENCES = {
+  userAutoApproveTools: [],
+  disabledTools: []
+};
+class InMemoryConversationStore {
+  messages = /* @__PURE__ */ new Map();
+  async listMessages(input) {
+    return cloneInternalMessages(this.messages.get(input.sessionId) ?? []);
+  }
+  async saveMessage(input) {
+    const messages = this.messages.get(input.sessionId) ?? [];
+    if (input.message.id && messages.some((message) => message.id === input.message.id)) {
+      return;
+    }
+    messages.push(cloneInternalMessage(input.message));
+    this.messages.set(input.sessionId, messages);
+  }
+  async updateMessage(input) {
+    if (!input.message.id) {
+      return;
+    }
+    const messages = this.messages.get(input.sessionId) ?? [];
+    const index = messages.findIndex((message) => message.id === input.message.id);
+    if (index === -1) {
+      return;
+    }
+    messages[index] = cloneInternalMessage(input.message);
+    this.messages.set(input.sessionId, messages);
+  }
+  async clearMessages(input) {
+    this.messages.delete(input.sessionId);
+  }
+  async flush(_input) {
+  }
+}
+class InMemoryApprovalStore {
+  requests = /* @__PURE__ */ new Map();
+  responses = /* @__PURE__ */ new Map();
+  sessionStates = /* @__PURE__ */ new Map();
+  async createRequest(input) {
+    const existing = this.requests.get(input.request.approvalId);
+    if (existing) {
+      return structuredClone(existing);
+    }
+    this.requests.set(input.request.approvalId, structuredClone(input.request));
+    return structuredClone(input.request);
+  }
+  async getRequest(input) {
+    const request = this.requests.get(input.approvalId);
+    return request ? structuredClone(request) : void 0;
+  }
+  async listPending(input) {
+    const pending = [];
+    for (const request of this.requests.values()) {
+      if (this.responses.has(request.approvalId)) {
+        continue;
+      }
+      if (input.sessionId !== void 0 && request.sessionId !== input.sessionId) {
+        continue;
+      }
+      pending.push(structuredClone(request));
+    }
+    return pending;
+  }
+  async saveResponse(input) {
+    const existing = this.responses.get(input.response.approvalId);
+    if (existing) {
+      return { response: structuredClone(existing), status: "replayed" };
+    }
+    this.responses.set(input.response.approvalId, structuredClone(input.response));
+    return { response: structuredClone(input.response), status: "created" };
+  }
+  async getResponse(input) {
+    const response = this.responses.get(input.approvalId);
+    return response ? structuredClone(response) : void 0;
+  }
+  async loadSessionState(input) {
+    return structuredClone(
+      this.sessionStates.get(input.sessionId ?? GLOBAL_SCOPE) ?? DEFAULT_APPROVAL_STATE
+    );
+  }
+  async saveSessionState(input) {
+    this.sessionStates.set(input.sessionId ?? GLOBAL_SCOPE, structuredClone(input.state));
+  }
+  async deleteSessionState(input) {
+    this.sessionStates.delete(input.sessionId ?? GLOBAL_SCOPE);
+  }
+}
+class InMemorySessionStore {
+  sessions = /* @__PURE__ */ new Map();
+  async listSessionIds() {
+    return Array.from(this.sessions.keys());
+  }
+  async getSession(input) {
+    const session = this.sessions.get(input.sessionId);
+    return session ? structuredClone(session) : void 0;
+  }
+  async saveSession(input) {
+    void input.ttlSeconds;
+    this.sessions.set(input.sessionId, structuredClone(input.session));
+  }
+  async deleteSession(input) {
+    this.sessions.delete(input.sessionId);
+  }
+  async evictSession(_input) {
+  }
+}
+class InMemoryMemoryStore {
+  memories = /* @__PURE__ */ new Map();
+  async create(input) {
+    this.memories.set(input.memory.id, structuredClone(input.memory));
+  }
+  async get(input) {
+    const memory = this.memories.get(input.id);
+    return memory ? structuredClone(memory) : void 0;
+  }
+  async update(input) {
+    this.memories.set(input.memory.id, structuredClone(input.memory));
+  }
+  async delete(input) {
+    this.memories.delete(input.id);
+  }
+  async list() {
+    return structuredClone(Array.from(this.memories.values()));
+  }
+}
+class InMemoryWorkspaceStore {
+  workspaces = /* @__PURE__ */ new Map();
+  currentWorkspaceId;
+  async saveWorkspace(input) {
+    this.workspaces.set(input.workspace.id, structuredClone(input.workspace));
+  }
+  async getWorkspace(input) {
+    const workspace = this.workspaces.get(input.id);
+    return workspace ? structuredClone(workspace) : void 0;
+  }
+  async findWorkspaceByPath(input) {
+    for (const workspace of this.workspaces.values()) {
+      if (workspace.path === input.path) {
+        return structuredClone(workspace);
+      }
+    }
+    return void 0;
+  }
+  async listWorkspaces() {
+    return structuredClone(Array.from(this.workspaces.values()));
+  }
+  async setCurrentWorkspace(input) {
+    this.currentWorkspaceId = input.id;
+  }
+  async getCurrentWorkspaceId() {
+    return this.currentWorkspaceId;
+  }
+  async clearCurrentWorkspace() {
+    this.currentWorkspaceId = void 0;
+  }
+}
+class InMemoryToolPreferenceStore {
+  allowedTools = /* @__PURE__ */ new Map();
+  sessionPreferences = /* @__PURE__ */ new Map();
+  async allowTool(input) {
+    this.getAllowedToolSet(input.sessionId).add(input.toolName);
+  }
+  async disallowTool(input) {
+    this.getAllowedToolSet(input.sessionId).delete(input.toolName);
+  }
+  async isToolAllowed(input) {
+    return this.getAllowedToolSet(input.sessionId).has(input.toolName) || this.getAllowedToolSet(void 0).has(input.toolName);
+  }
+  async listAllowedTools(input) {
+    return Array.from(this.getAllowedToolSet(input.sessionId));
+  }
+  async loadSessionPreferences(input) {
+    return structuredClone(
+      this.sessionPreferences.get(input.sessionId) ?? DEFAULT_TOOL_PREFERENCES
+    );
+  }
+  async saveSessionPreferences(input) {
+    this.sessionPreferences.set(input.sessionId, structuredClone(input.preferences));
+  }
+  async deleteSessionPreferences(input) {
+    this.sessionPreferences.delete(input.sessionId);
+  }
+  getAllowedToolSet(sessionId) {
+    const key = sessionId ?? GLOBAL_SCOPE;
+    const existing = this.allowedTools.get(key);
+    if (existing) {
+      return existing;
+    }
+    const tools = /* @__PURE__ */ new Set();
+    this.allowedTools.set(key, tools);
+    return tools;
+  }
+}
+class InMemorySessionMessageQueueStore {
+  queues = /* @__PURE__ */ new Map();
+  async listSessionIds() {
+    return Array.from(this.queues.keys());
+  }
+  async load(input) {
+    return cloneQueuedMessages(this.queues.get(input.sessionId) ?? []);
+  }
+  async save(input) {
+    if (input.queue.length === 0) {
+      this.queues.delete(input.sessionId);
+      return;
+    }
+    this.queues.set(input.sessionId, cloneQueuedMessages(input.queue));
+  }
+  async delete(input) {
+    this.queues.delete(input.sessionId);
+  }
+}
+class InMemoryCustomPromptStore {
+  prompts = /* @__PURE__ */ new Map();
+  async save(input) {
+    this.prompts.set(input.prompt.name, structuredClone(input.prompt));
+  }
+  async get(input) {
+    const prompt = this.prompts.get(input.name);
+    return prompt ? structuredClone(prompt) : void 0;
+  }
+  async delete(input) {
+    this.prompts.delete(input.name);
+  }
+  async list() {
+    return structuredClone(Array.from(this.prompts.values()));
+  }
+}
+class InMemoryArtifactStore {
+  artifacts = /* @__PURE__ */ new Map();
+  async store(input) {
+    const data = this.toBuffer(input.data);
+    const id = randomUUID();
+    const hash = createHash("sha256").update(data).digest("hex");
+    const metadata = this.createMetadata(id, data, hash, input.metadata);
+    this.artifacts.set(id, { data, metadata });
+    return { id, uri: `blob:${id}`, metadata: structuredClone(metadata) };
+  }
+  async retrieve(input) {
+    const id = this.toId(input.reference);
+    const artifact = this.artifacts.get(id);
+    if (!artifact) {
+      throw StorageError.blobNotFound(input.reference);
+    }
+    if (input.format === "buffer") {
+      return {
+        format: "buffer",
+        data: Buffer.from(artifact.data),
+        metadata: structuredClone(artifact.metadata)
+      };
+    }
+    return {
+      format: "base64",
+      data: artifact.data.toString("base64"),
+      metadata: structuredClone(artifact.metadata)
+    };
+  }
+  async exists(input) {
+    return this.artifacts.has(this.toId(input.reference));
+  }
+  async delete(input) {
+    this.artifacts.delete(this.toId(input.reference));
+  }
+  async cleanup(input = {}) {
+    let deleted = 0;
+    for (const [id, artifact] of this.artifacts.entries()) {
+      if (input.olderThan && artifact.metadata.createdAt >= input.olderThan) {
+        continue;
+      }
+      this.artifacts.delete(id);
+      deleted++;
+    }
+    return deleted;
+  }
+  async getStats() {
+    let totalSize = 0;
+    for (const artifact of this.artifacts.values()) {
+      totalSize += artifact.metadata.size;
+    }
+    return {
+      count: this.artifacts.size,
+      totalSize,
+      backendType: "in-memory"
+    };
+  }
+  async listArtifacts() {
+    return Array.from(this.artifacts.values()).map((artifact) => ({
+      id: artifact.metadata.id,
+      uri: `blob:${artifact.metadata.id}`,
+      metadata: structuredClone(artifact.metadata)
+    }));
+  }
+  getStoragePath() {
+    return void 0;
+  }
+  toBuffer(input) {
+    if (typeof input === "string") {
+      return Buffer.from(input, "base64");
+    }
+    if (input instanceof Uint8Array) {
+      return Buffer.from(input);
+    }
+    return Buffer.from(input);
+  }
+  createMetadata(id, data, hash, metadata) {
+    return {
+      id,
+      mimeType: metadata?.mimeType ?? "application/octet-stream",
+      ...metadata?.originalName !== void 0 && { originalName: metadata.originalName },
+      createdAt: metadata?.createdAt ?? /* @__PURE__ */ new Date(),
+      size: metadata?.size ?? data.byteLength,
+      hash,
+      ...metadata?.source !== void 0 && { source: metadata.source }
+    };
+  }
+  toId(reference) {
+    if (reference.startsWith("artifact:")) {
+      return reference.slice("artifact:".length);
+    }
+    if (reference.startsWith("blob:")) {
+      return reference.slice("blob:".length);
+    }
+    return reference;
+  }
+}
+class InMemoryRuntimeEventStore {
+  events = [];
+  async append(input) {
+    this.events.push(structuredClone(input.event));
+  }
+  async list(input) {
+    const events = this.events.filter((event) => {
+      if (input.sessionId !== void 0 && event.sessionId !== input.sessionId) {
+        return false;
+      }
+      if (input.runId !== void 0 && event.runId !== input.runId) {
+        return false;
+      }
+      return true;
+    });
+    return structuredClone(input.limit === void 0 ? events : events.slice(-input.limit));
+  }
+}
+class InMemoryToolStateStore {
+  values = /* @__PURE__ */ new Map();
+  async get(input) {
+    return structuredClone(this.values.get(this.toKey(input)));
+  }
+  async set(input) {
+    this.values.set(this.toKey(input), structuredClone(input.value));
+  }
+  async delete(input) {
+    this.values.delete(this.toKey(input));
+  }
+  async listKeys(input) {
+    const prefix = this.toKey({ toolName: input.toolName, key: input.prefix ?? "" });
+    return Array.from(this.values.keys()).filter((key) => key.startsWith(prefix)).map((key) => key.slice(this.toKey({ toolName: input.toolName, key: "" }).length));
+  }
+  toKey(input) {
+    return `${input.toolName}:${input.key}`;
+  }
+}
+class InMemoryToolExecutionStore {
+  records = /* @__PURE__ */ new Map();
+  async get(input) {
+    const record = this.records.get(input.executionId);
+    return record ? structuredClone(record) : void 0;
+  }
+  async start(input) {
+    const existing = this.records.get(input.record.executionId);
+    if (existing) {
+      return { status: "existing", record: structuredClone(existing) };
+    }
+    this.records.set(input.record.executionId, structuredClone(input.record));
+    return { status: "started", record: structuredClone(input.record) };
+  }
+  async complete(input) {
+    const existing = this.requireRecord(input.executionId);
+    if (existing.status === "completed") {
+      return structuredClone(existing);
+    }
+    if (existing.status !== "running") {
+      throw new Error(`Tool execution is already ${existing.status}: ${input.executionId}`);
+    }
+    const resultParts = splitToolExecutionResult(input.result);
+    const record = {
+      ...existing,
+      status: "completed",
+      completedAt: input.completedAt,
+      updatedAt: input.completedAt,
+      ...resultParts
+    };
+    this.records.set(input.executionId, structuredClone(record));
+    return structuredClone(record);
+  }
+  async fail(input) {
+    const existing = this.requireRecord(input.executionId);
+    if (existing.status === "failed") {
+      return structuredClone(existing);
+    }
+    if (existing.status !== "running") {
+      throw new Error(`Tool execution is already ${existing.status}: ${input.executionId}`);
+    }
+    const record = {
+      ...existing,
+      status: "failed",
+      completedAt: input.completedAt,
+      updatedAt: input.completedAt,
+      error: input.error
+    };
+    this.records.set(input.executionId, structuredClone(record));
+    return structuredClone(record);
+  }
+  async cancel(input) {
+    const existing = this.requireRecord(input.executionId);
+    if (existing.status === "cancelled") {
+      return structuredClone(existing);
+    }
+    if (existing.status !== "running") {
+      throw new Error(`Tool execution is already ${existing.status}: ${input.executionId}`);
+    }
+    const record = {
+      ...existing,
+      status: "cancelled",
+      completedAt: input.completedAt,
+      updatedAt: input.completedAt,
+      ...input.reason !== void 0 ? { reason: input.reason } : {}
+    };
+    this.records.set(input.executionId, structuredClone(record));
+    return structuredClone(record);
+  }
+  requireRecord(executionId) {
+    const existing = this.records.get(executionId);
+    if (!existing) {
+      throw new Error(`Tool execution record not found: ${executionId}`);
+    }
+    return existing;
+  }
+}
+class InMemoryDextoStores {
+  connected = false;
+  stores = {
+    conversation: new InMemoryConversationStore(),
+    sessions: new InMemorySessionStore(),
+    memories: new InMemoryMemoryStore(),
+    workspaces: new InMemoryWorkspaceStore(),
+    approvals: new InMemoryApprovalStore(),
+    toolPreferences: new InMemoryToolPreferenceStore(),
+    toolState: new InMemoryToolStateStore(),
+    steerQueue: new InMemorySessionMessageQueueStore(),
+    followUpQueue: new InMemorySessionMessageQueueStore(),
+    customPrompts: new InMemoryCustomPromptStore(),
+    artifacts: new InMemoryArtifactStore(),
+    runtimeEvents: new InMemoryRuntimeEventStore(),
+    toolExecutions: new InMemoryToolExecutionStore()
+  };
+  getStore(name) {
+    return this.stores[name];
+  }
+  async connect() {
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getStoreType() {
+    return "in-memory";
+  }
+}
+export {
+  InMemoryDextoStores
+};

package/dist/storage/stores/types.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/storage/stores/types.d.ts

@@ -0,0 +1,36 @@
+import type { ApprovalStore } from '../approvals/types.js';
+import type { ArtifactStore } from '../artifacts/types.js';
+import type { ConversationStore } from '../conversation/types.js';
+import type { MemoryStore } from '../memories/types.js';
+import type { SessionMessageQueueStore } from '../message-queue/types.js';
+import type { CustomPromptStore } from '../prompts/types.js';
+import type { RuntimeEventStore } from '../runtime-events/types.js';
+import type { SessionStore } from '../sessions/types.js';
+import type { ToolExecutionStore } from '../tool-executions/types.js';
+import type { ToolStateStore } from '../tool-state/types.js';
+import type { ToolPreferenceStore } from '../tool-preferences/types.js';
+import type { WorkspaceStore } from '../workspaces/types.js';
+export interface DextoStoreMap {
+    conversation: ConversationStore;
+    sessions: SessionStore;
+    memories: MemoryStore;
+    workspaces: WorkspaceStore;
+    approvals: ApprovalStore;
+    toolPreferences: ToolPreferenceStore;
+    toolState: ToolStateStore;
+    steerQueue: SessionMessageQueueStore;
+    followUpQueue: SessionMessageQueueStore;
+    customPrompts: CustomPromptStore;
+    artifacts: ArtifactStore;
+    runtimeEvents: RuntimeEventStore;
+    toolExecutions: ToolExecutionStore;
+}
+export type DextoStoreName = keyof DextoStoreMap;
+export interface DextoStores {
+    getStore<K extends DextoStoreName>(name: K): DextoStoreMap[K];
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getStoreType(): string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/storage/stores/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/storage/stores/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,MAAM,WAAW,aAAa;IAC1B,YAAY,EAAE,iBAAiB,CAAC;IAChC,QAAQ,EAAE,YAAY,CAAC;IACvB,QAAQ,EAAE,WAAW,CAAC;IACtB,UAAU,EAAE,cAAc,CAAC;IAC3B,SAAS,EAAE,aAAa,CAAC;IACzB,eAAe,EAAE,mBAAmB,CAAC;IACrC,SAAS,EAAE,cAAc,CAAC;IAC1B,UAAU,EAAE,wBAAwB,CAAC;IACrC,aAAa,EAAE,wBAAwB,CAAC;IACxC,aAAa,EAAE,iBAAiB,CAAC;IACjC,SAAS,EAAE,aAAa,CAAC;IACzB,aAAa,EAAE,iBAAiB,CAAC;IACjC,cAAc,EAAE,kBAAkB,CAAC;CACtC;AAED,MAAM,MAAM,cAAc,GAAG,MAAM,aAAa,CAAC;AAEjD,MAAM,WAAW,WAAW;IACxB,QAAQ,CAAC,CAAC,SAAS,cAAc,EAAE,IAAI,EAAE,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;IAC9D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,WAAW,IAAI,OAAO,CAAC;IACvB,YAAY,IAAI,MAAM,CAAC;CAC1B"}

package/dist/storage/tool-executions/types.cjs

@@ -0,0 +1,127 @@
+"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);
+var types_exports = {};
+__export(types_exports, {
+  ToolExecutionCancelledRecordSchema: () => ToolExecutionCancelledRecordSchema,
+  ToolExecutionCompletedRecordSchema: () => ToolExecutionCompletedRecordSchema,
+  ToolExecutionFailedRecordSchema: () => ToolExecutionFailedRecordSchema,
+  ToolExecutionIdentitySchema: () => ToolExecutionIdentitySchema,
+  ToolExecutionRecordSchema: () => ToolExecutionRecordSchema,
+  ToolExecutionRunningRecordSchema: () => ToolExecutionRunningRecordSchema,
+  completedToolExecutionToResult: () => completedToolExecutionToResult,
+  createToolExecutionId: () => createToolExecutionId,
+  splitToolExecutionResult: () => splitToolExecutionResult
+});
+module.exports = __toCommonJS(types_exports);
+var import_crypto = require("crypto");
+var import_zod = require("zod");
+const ToolExecutionIdentitySchema = import_zod.z.object({
+  runId: import_zod.z.string().min(1),
+  turnId: import_zod.z.string().min(1),
+  modelStepId: import_zod.z.string().min(1),
+  toolCallId: import_zod.z.string().min(1)
+}).strict();
+const ToolExecutionResultMetadataSchema = import_zod.z.object({
+  presentationSnapshot: import_zod.z.custom().optional(),
+  meta: import_zod.z.custom().optional(),
+  requireApproval: import_zod.z.boolean().optional(),
+  approvalStatus: import_zod.z.enum(["approved", "rejected"]).optional()
+}).strict();
+const ToolExecutionBaseRecordSchema = import_zod.z.object({
+  executionId: import_zod.z.string().min(1),
+  identity: ToolExecutionIdentitySchema,
+  input: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()),
+  toolName: import_zod.z.string().min(1),
+  startedAt: import_zod.z.coerce.date(),
+  updatedAt: import_zod.z.coerce.date()
+}).strict();
+const ToolExecutionRunningRecordSchema = ToolExecutionBaseRecordSchema.extend({
+  status: import_zod.z.literal("running")
+}).strict();
+const ToolExecutionCompletedRecordSchema = ToolExecutionBaseRecordSchema.extend({
+  status: import_zod.z.literal("completed"),
+  completedAt: import_zod.z.coerce.date(),
+  modelOutput: import_zod.z.unknown(),
+  resultMetadata: ToolExecutionResultMetadataSchema.optional()
+}).strict();
+const ToolExecutionFailedRecordSchema = ToolExecutionBaseRecordSchema.extend({
+  status: import_zod.z.literal("failed"),
+  completedAt: import_zod.z.coerce.date(),
+  error: import_zod.z.string()
+}).strict();
+const ToolExecutionCancelledRecordSchema = ToolExecutionBaseRecordSchema.extend({
+  status: import_zod.z.literal("cancelled"),
+  completedAt: import_zod.z.coerce.date(),
+  reason: import_zod.z.string().optional()
+}).strict();
+const ToolExecutionRecordSchema = import_zod.z.discriminatedUnion("status", [
+  ToolExecutionRunningRecordSchema,
+  ToolExecutionCompletedRecordSchema,
+  ToolExecutionFailedRecordSchema,
+  ToolExecutionCancelledRecordSchema
+]);
+function createToolExecutionId(identity) {
+  const key = JSON.stringify([
+    identity.runId,
+    identity.turnId,
+    identity.modelStepId,
+    identity.toolCallId
+  ]);
+  return `tool-exec-${(0, import_crypto.createHash)("sha256").update(key).digest("hex")}`;
+}
+function splitToolExecutionResult(result) {
+  const resultMetadata = {};
+  if (result.presentationSnapshot !== void 0) {
+    resultMetadata.presentationSnapshot = result.presentationSnapshot;
+  }
+  if (result.meta !== void 0) {
+    resultMetadata.meta = result.meta;
+  }
+  if (result.requireApproval !== void 0) {
+    resultMetadata.requireApproval = result.requireApproval;
+  }
+  if (result.approvalStatus !== void 0) {
+    resultMetadata.approvalStatus = result.approvalStatus;
+  }
+  return {
+    modelOutput: result.result,
+    ...Object.keys(resultMetadata).length > 0 ? { resultMetadata } : {}
+  };
+}
+function completedToolExecutionToResult(record) {
+  return {
+    result: record.modelOutput,
+    ...record.resultMetadata?.presentationSnapshot !== void 0 ? { presentationSnapshot: record.resultMetadata.presentationSnapshot } : {},
+    ...record.resultMetadata?.meta !== void 0 ? { meta: record.resultMetadata.meta } : {},
+    ...record.resultMetadata?.requireApproval !== void 0 ? { requireApproval: record.resultMetadata.requireApproval } : {},
+    ...record.resultMetadata?.approvalStatus !== void 0 ? { approvalStatus: record.resultMetadata.approvalStatus } : {}
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToolExecutionCancelledRecordSchema,
+  ToolExecutionCompletedRecordSchema,
+  ToolExecutionFailedRecordSchema,
+  ToolExecutionIdentitySchema,
+  ToolExecutionRecordSchema,
+  ToolExecutionRunningRecordSchema,
+  completedToolExecutionToResult,
+  createToolExecutionId,
+  splitToolExecutionResult
+});