@iqai/adk 0.7.0 → 0.8.0

package/dist/index.mjs

@@ -9972,10 +9972,13 @@ __export(tools_exports, {
   McpMemory: () => McpMemory,
   McpNearAgent: () => McpNearAgent,
   McpNearIntents: () => McpNearIntents,
+  McpNotion: () => McpNotion,
   McpOdos: () => McpOdos,
   McpOpinion: () => McpOpinion,
+  McpPlaywright: () => McpPlaywright,
   McpPolymarket: () => McpPolymarket,
   McpSamplingHandler: () => McpSamplingHandler,
+  McpSequentialThinking: () => McpSequentialThinking,
   McpTelegram: () => McpTelegram,
   McpToolset: () => McpToolset,
   McpUpbit: () => McpUpbit,
@@ -13426,11 +13429,16 @@ async function convertMcpToolToBaseTool(params) {
     throw error;
   }
 }
+function sanitizeMcpToolName(name) {
+  return name.replace(/-/g, "_");
+}
 var McpToolAdapter = class extends BaseTool {
   mcpTool;
   client;
   clientService = null;
   toolHandler;
+  /** The original MCP tool name, preserved for calls back to the MCP server. */
+  originalMcpName;
   logger = new Logger({ name: "McpToolAdapter" });
   constructor(mcpTool, client, handler) {
     let metadata = {};
@@ -13439,13 +13447,15 @@ var McpToolAdapter = class extends BaseTool {
     } else if (mcpTool._meta && typeof mcpTool._meta === "object") {
       metadata = mcpTool._meta;
     }
+    const rawName = mcpTool.name || `mcp_${Date.now()}`;
     super({
-      name: mcpTool.name || `mcp_${Date.now()}`,
+      name: sanitizeMcpToolName(rawName),
       description: mcpTool.description || "MCP Tool",
       isLongRunning: metadata.isLongRunning ?? false,
       shouldRetryOnFailure: metadata.shouldRetryOnFailure ?? false,
       maxRetryAttempts: metadata.maxRetryAttempts ?? 3
     });
+    this.originalMcpName = rawName;
     this.mcpTool = mcpTool;
     this.client = client;
     this.toolHandler = handler;
@@ -13470,27 +13480,30 @@ var McpToolAdapter = class extends BaseTool {
     }
   }
   async runAsync(args, _context) {
-    this.logger.debug(`Executing MCP tool ${this.name} with args:`, args);
+    this.logger.debug(
+      `Executing MCP tool ${this.originalMcpName} with args:`,
+      args
+    );
     try {
       if ("execute" in this.mcpTool && typeof this.mcpTool.execute === "function") {
         return await this.mcpTool.execute(args);
       }
       if (this.clientService) {
-        return await this.clientService.callTool(this.name, args);
+        return await this.clientService.callTool(this.originalMcpName, args);
       }
       if (this.client && typeof this.client.callTool === "function") {
         if (this.shouldRetryOnFailure) {
           const executeWithRetry = withRetry(
             async () => {
               return await this.client.callTool({
-                name: this.name,
+                name: this.originalMcpName,
                 arguments: args
               });
             },
             this,
             async () => {
               console.warn(
-                `MCP tool ${this.name} encountered a closed resource, but cannot reinitialize client.`
+                `MCP tool ${this.originalMcpName} encountered a closed resource, but cannot reinitialize client.`
               );
             },
             this.maxRetryAttempts
@@ -13498,23 +13511,26 @@ var McpToolAdapter = class extends BaseTool {
           return await executeWithRetry();
         }
         const result = await this.client.callTool({
-          name: this.name,
+          name: this.originalMcpName,
           arguments: args
         });
         return result;
       }
       if (this.toolHandler) {
-        return await this.toolHandler(this.name, args);
+        return await this.toolHandler(this.originalMcpName, args);
       }
       throw new McpError(
-        `Cannot execute MCP tool ${this.name}: No execution method found`,
+        `Cannot execute MCP tool ${this.originalMcpName}: No execution method found`,
         "tool_execution_error" /* TOOL_EXECUTION_ERROR */
       );
     } catch (error) {
       if (!(error instanceof McpError)) {
-        console.error(`Error executing MCP tool ${this.name}:`, error);
+        console.error(
+          `Error executing MCP tool ${this.originalMcpName}:`,
+          error
+        );
         throw new McpError(
-          `Error executing MCP tool ${this.name}: ${error instanceof Error ? error.message : String(error)}`,
+          `Error executing MCP tool ${this.originalMcpName}: ${error instanceof Error ? error.message : String(error)}`,
           "tool_execution_error" /* TOOL_EXECUTION_ERROR */,
           error instanceof Error ? error : void 0
         );
@@ -13724,6 +13740,30 @@ function McpMemory(config = {}) {
   );
   return new McpToolset(mcpConfig);
 }
+function McpNotion(config = {}) {
+  const mcpConfig = createMcpConfig(
+    "Notion MCP Client",
+    "@notionhq/notion-mcp-server",
+    config
+  );
+  return new McpToolset(mcpConfig);
+}
+function McpSequentialThinking(config = {}) {
+  const mcpConfig = createMcpConfig(
+    "Sequential Thinking MCP Client",
+    "@modelcontextprotocol/server-sequential-thinking",
+    config
+  );
+  return new McpToolset(mcpConfig);
+}
+function McpPlaywright(config = {}) {
+  const mcpConfig = createMcpConfig(
+    "Playwright MCP Client",
+    "@playwright/mcp",
+    config
+  );
+  return new McpToolset(mcpConfig);
+}
 function McpGeneric(packageName, config = {}, name) {
   const clientName = name || `${packageName} Client`;
   const mcpConfig = createMcpConfig(clientName, packageName, config);
@@ -23380,6 +23420,494 @@ function streamTextWithFinalEvent(events) {
   };
 }
 
+// src/unified-memory/index.ts
+var unified_memory_exports = {};
+__export(unified_memory_exports, {
+  MemoryBuilder: () => MemoryBuilder,
+  defaultUnifiedMemoryConfig: () => defaultUnifiedMemoryConfig
+});
+
+// src/unified-memory/types.ts
+var defaultUnifiedMemoryConfig = {
+  lastMessages: 40
+};
+
+// src/unified-memory/memory-builder.ts
+var WORKING_MEMORY_KEY = "__working_memory__";
+var MemoryBuilder = class _MemoryBuilder {
+  sessionService;
+  memoryService;
+  appName;
+  userId;
+  lastMessages;
+  workingMemoryEnabled;
+  workingMemoryTemplate;
+  constructor(config) {
+    this.appName = config.appName;
+    this.userId = config.userId;
+    this.lastMessages = config.lastMessages ?? defaultUnifiedMemoryConfig.lastMessages;
+    this.sessionService = new InMemorySessionService();
+    this.workingMemoryEnabled = config.workingMemory?.enabled ?? false;
+    this.workingMemoryTemplate = config.workingMemory?.template;
+  }
+  static create(config) {
+    return new _MemoryBuilder(config);
+  }
+  withSessionService(service) {
+    this.sessionService = service;
+    return this;
+  }
+  withMemoryService(service) {
+    this.memoryService = service;
+    return this;
+  }
+  withAppName(appName) {
+    this.appName = appName;
+    return this;
+  }
+  withUserId(userId) {
+    this.userId = userId;
+    return this;
+  }
+  async createSession(state, sessionId) {
+    const initialState = { ...state };
+    if (this.workingMemoryEnabled && this.workingMemoryTemplate) {
+      initialState[WORKING_MEMORY_KEY] = this.workingMemoryTemplate;
+    }
+    return this.sessionService.createSession(
+      this.appName,
+      this.userId,
+      initialState,
+      sessionId
+    );
+  }
+  async getSession(sessionId) {
+    return this.sessionService.getSession(this.appName, this.userId, sessionId);
+  }
+  async listSessions() {
+    return this.sessionService.listSessions(this.appName, this.userId);
+  }
+  async deleteSession(sessionId) {
+    return this.sessionService.deleteSession(
+      this.appName,
+      this.userId,
+      sessionId
+    );
+  }
+  async addMessage(session, message) {
+    const author = message.role === "user" ? "user" : message.role === "assistant" ? "model" : "system";
+    const event = new Event({
+      author,
+      content: {
+        role: author,
+        parts: [{ text: message.content }]
+      }
+    });
+    const appended = await this.sessionService.appendEvent(session, event);
+    if (this.memoryService) {
+      await this.memoryService.addSessionToMemory(session);
+    }
+    return appended;
+  }
+  async addEvent(session, event) {
+    const appended = await this.sessionService.appendEvent(session, event);
+    if (this.memoryService) {
+      await this.memoryService.addSessionToMemory(session);
+    }
+    return appended;
+  }
+  async recall(sessionId) {
+    const session = await this.sessionService.getSession(
+      this.appName,
+      this.userId,
+      sessionId,
+      this.lastMessages === false ? void 0 : { numRecentEvents: this.lastMessages }
+    );
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    return session.events.map((event) => ({
+      role: this.eventAuthorToRole(event.author),
+      content: this.extractEventText(event)
+    }));
+  }
+  async recallEvents(sessionId) {
+    const session = await this.sessionService.getSession(
+      this.appName,
+      this.userId,
+      sessionId,
+      this.lastMessages === false ? void 0 : { numRecentEvents: this.lastMessages }
+    );
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    return session.events;
+  }
+  async search(query) {
+    if (!this.memoryService) {
+      throw new Error(
+        "MemoryService is required for search. Use withMemoryService() to configure one."
+      );
+    }
+    return this.memoryService.search({
+      query,
+      userId: this.userId,
+      appName: this.appName
+    });
+  }
+  async getWorkingMemory(sessionId) {
+    const session = await this.sessionService.getSession(
+      this.appName,
+      this.userId,
+      sessionId
+    );
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const stored = session.state[WORKING_MEMORY_KEY];
+    if (stored) return stored;
+    if (this.workingMemoryEnabled && this.workingMemoryTemplate) {
+      return this.workingMemoryTemplate;
+    }
+    return null;
+  }
+  async updateWorkingMemory(session, content) {
+    const event = new Event({
+      author: "system",
+      actions: new EventActions({
+        stateDelta: { [WORKING_MEMORY_KEY]: content }
+      })
+    });
+    await this.sessionService.appendEvent(session, event);
+  }
+  async endSession(sessionId) {
+    const session = await this.sessionService.endSession(
+      this.appName,
+      this.userId,
+      sessionId
+    );
+    if (session && this.memoryService) {
+      await this.memoryService.addSessionToMemory(session);
+    }
+    return session;
+  }
+  getSessionService() {
+    return this.sessionService;
+  }
+  getMemoryService() {
+    return this.memoryService;
+  }
+  eventAuthorToRole(author) {
+    if (author === "user") return "user";
+    if (author === "system") return "system";
+    return "assistant";
+  }
+  extractEventText(event) {
+    if (event.text) return event.text;
+    if (event.content?.parts && Array.isArray(event.content.parts)) {
+      const textParts = event.content.parts.filter(
+        (part) => typeof part.text === "string" && part.text.length > 0
+      ).map((part) => part.text);
+      if (textParts.length > 0) return textParts.join(" ");
+    }
+    return "";
+  }
+};
+
+// src/workflows/index.ts
+var workflows_exports = {};
+__export(workflows_exports, {
+  InMemorySnapshotStore: () => InMemorySnapshotStore,
+  Run: () => Run,
+  Workflow: () => Workflow,
+  createStep: () => createStep,
+  createWorkflow: () => createWorkflow
+});
+
+// src/workflows/step.ts
+function createStep(definition) {
+  return {
+    id: definition.id,
+    description: definition.description,
+    inputSchema: definition.inputSchema,
+    outputSchema: definition.outputSchema,
+    resumeSchema: definition.resumeSchema,
+    suspendSchema: definition.suspendSchema,
+    execute: definition.execute
+  };
+}
+
+// src/workflows/workflow.ts
+var SuspendError = class extends Error {
+  constructor(suspendPayload) {
+    super("Workflow suspended");
+    this.suspendPayload = suspendPayload;
+    this.name = "SuspendError";
+  }
+};
+function generateRunId() {
+  return `run_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+var Run = class _Run {
+  constructor(workflow, runId) {
+    this.workflow = workflow;
+    this.runId = runId ?? generateRunId();
+    this.createdAt = Date.now();
+    this.updatedAt = this.createdAt;
+  }
+  runId;
+  status = "pending";
+  stepResults = {};
+  suspendedStepId;
+  suspendPayload;
+  result;
+  input;
+  createdAt;
+  updatedAt;
+  async start(input) {
+    if (this.status !== "pending") {
+      throw new Error(`Cannot start run in status: ${this.status}`);
+    }
+    this.input = input;
+    this.status = "running";
+    return this.executeSteps(0);
+  }
+  async resume(options) {
+    if (this.status !== "suspended") {
+      throw new Error(`Cannot resume run in status: ${this.status}`);
+    }
+    const stepId = options.step ?? this.suspendedStepId;
+    if (!stepId) {
+      throw new Error("No suspended step to resume");
+    }
+    const stepIndex = this.workflow.stepGraph.findIndex((s) => s.id === stepId);
+    if (stepIndex === -1) {
+      throw new Error(`Step not found: ${stepId}`);
+    }
+    this.status = "running";
+    return this.executeSteps(stepIndex, options.resumeData);
+  }
+  async executeSteps(startIndex, resumeData) {
+    const steps = this.workflow.stepGraph;
+    let isFirstResumedStep = resumeData !== void 0;
+    for (let i = startIndex; i < steps.length; i++) {
+      const step = steps[i];
+      const startedAt = Date.now();
+      const context4 = {
+        runId: this.runId,
+        workflowId: this.workflow.id,
+        inputData: this.input,
+        resumeData: isFirstResumedStep ? resumeData : void 0,
+        suspend: (payload) => {
+          throw new SuspendError(payload);
+        },
+        getStepResult: (stepId) => {
+          const result = this.stepResults[stepId];
+          if (result?.status === "success") {
+            return result.output;
+          }
+          return void 0;
+        }
+      };
+      try {
+        const output = await step.execute(context4);
+        const endedAt = Date.now();
+        const previousResult = this.stepResults[step.id];
+        if (previousResult?.status === "suspended") {
+          this.stepResults[step.id] = {
+            status: "success",
+            output,
+            payload: this.input,
+            resumePayload: resumeData,
+            startedAt: previousResult.startedAt,
+            endedAt,
+            suspendedAt: previousResult.suspendedAt,
+            resumedAt: startedAt
+          };
+        } else {
+          this.stepResults[step.id] = {
+            status: "success",
+            output,
+            payload: this.input,
+            startedAt,
+            endedAt
+          };
+        }
+        isFirstResumedStep = false;
+      } catch (err) {
+        if (err instanceof SuspendError) {
+          this.status = "suspended";
+          this.suspendedStepId = step.id;
+          this.suspendPayload = err.suspendPayload;
+          this.stepResults[step.id] = {
+            status: "suspended",
+            payload: this.input,
+            suspendPayload: err.suspendPayload,
+            startedAt,
+            suspendedAt: Date.now()
+          };
+          await this.saveSnapshot();
+          return {
+            status: "suspended",
+            steps: this.stepResults,
+            suspendedStep: step.id,
+            suspendPayload: err.suspendPayload
+          };
+        }
+        this.status = "failed";
+        const error = err instanceof Error ? err : new Error(String(err));
+        this.stepResults[step.id] = {
+          status: "failed",
+          error,
+          payload: this.input,
+          startedAt,
+          endedAt: Date.now()
+        };
+        return {
+          status: "failed",
+          error,
+          steps: this.stepResults
+        };
+      }
+    }
+    this.status = "success";
+    const lastStep = steps[steps.length - 1];
+    const lastResult = this.stepResults[lastStep.id];
+    this.result = lastResult?.status === "success" ? lastResult.output : void 0;
+    await this.workflow.snapshotStore?.delete(this.workflow.id, this.runId);
+    return {
+      status: "success",
+      result: this.result,
+      steps: this.stepResults
+    };
+  }
+  async saveSnapshot() {
+    if (!this.workflow.snapshotStore) return;
+    const snapshot = {
+      runId: this.runId,
+      workflowId: this.workflow.id,
+      status: this.status,
+      input: this.input,
+      stepResults: this.stepResults,
+      suspendedStepId: this.suspendedStepId,
+      suspendPayload: this.suspendPayload,
+      createdAt: this.createdAt,
+      updatedAt: Date.now()
+    };
+    await this.workflow.snapshotStore.save(snapshot);
+  }
+  getStatus() {
+    return this.status;
+  }
+  getStepResults() {
+    return this.stepResults;
+  }
+  getSuspendedStepId() {
+    return this.suspendedStepId;
+  }
+  static async fromSnapshot(workflow, snapshot) {
+    const run = new _Run(workflow, snapshot.runId);
+    run.status = snapshot.status;
+    run.input = snapshot.input;
+    run.stepResults = snapshot.stepResults;
+    run.suspendedStepId = snapshot.suspendedStepId;
+    run.suspendPayload = snapshot.suspendPayload;
+    run.createdAt = snapshot.createdAt;
+    run.updatedAt = snapshot.updatedAt;
+    return run;
+  }
+};
+var Workflow = class {
+  id;
+  description;
+  inputSchema;
+  outputSchema;
+  stepGraph = [];
+  snapshotStore;
+  committed = false;
+  constructor(config) {
+    this.id = config.id;
+    this.description = config.description;
+    this.inputSchema = config.inputSchema;
+    this.outputSchema = config.outputSchema;
+  }
+  step(step) {
+    if (this.committed) {
+      throw new Error("Cannot add steps to a committed workflow");
+    }
+    this.stepGraph.push(step);
+    return this;
+  }
+  withSnapshotStore(store) {
+    this.snapshotStore = store;
+    return this;
+  }
+  commit() {
+    if (this.stepGraph.length === 0) {
+      throw new Error("Workflow must have at least one step");
+    }
+    this.committed = true;
+    return this;
+  }
+  createRun(runId) {
+    if (!this.committed) {
+      throw new Error("Workflow must be committed before creating a run");
+    }
+    return new Run(this, runId);
+  }
+  async resumeRun(runId) {
+    if (!this.snapshotStore) {
+      throw new Error("Cannot resume run without a snapshot store configured");
+    }
+    const snapshot = await this.snapshotStore.load(this.id, runId);
+    if (!snapshot) {
+      return null;
+    }
+    return Run.fromSnapshot(this, snapshot);
+  }
+  async listRuns() {
+    if (!this.snapshotStore) {
+      return [];
+    }
+    return this.snapshotStore.list(this.id);
+  }
+};
+function createWorkflow(config) {
+  return new Workflow(config);
+}
+
+// src/workflows/snapshot-store.ts
+var InMemorySnapshotStore = class {
+  snapshots = /* @__PURE__ */ new Map();
+  getKey(workflowId, runId) {
+    return `${workflowId}:${runId}`;
+  }
+  async save(snapshot) {
+    const key = this.getKey(snapshot.workflowId, snapshot.runId);
+    this.snapshots.set(key, { ...snapshot, updatedAt: Date.now() });
+  }
+  async load(workflowId, runId) {
+    const key = this.getKey(workflowId, runId);
+    return this.snapshots.get(key) ?? null;
+  }
+  async delete(workflowId, runId) {
+    const key = this.getKey(workflowId, runId);
+    this.snapshots.delete(key);
+  }
+  async list(workflowId) {
+    const results = [];
+    for (const [key, snapshot] of this.snapshots) {
+      if (key.startsWith(`${workflowId}:`)) {
+        results.push(snapshot);
+      }
+    }
+    return results;
+  }
+  clear() {
+    this.snapshots.clear();
+  }
+};
+
 // src/version.ts
 var VERSION = "0.1.0";
 export {
@@ -23459,6 +23987,7 @@ export {
   InMemoryMemoryService,
   InMemoryRunner,
   InMemorySessionService,
+  InMemorySnapshotStore,
   InMemoryStorageProvider,
   InMemoryVectorStore,
   InvocationContext,
@@ -23496,14 +24025,18 @@ export {
   McpMemory,
   McpNearAgent,
   McpNearIntents,
+  McpNotion,
   McpOdos,
   McpOpinion,
+  McpPlaywright,
   McpPolymarket,
   McpSamplingHandler,
+  McpSequentialThinking,
   McpTelegram,
   McpToolset,
   McpUpbit,
   memory_exports as Memory,
+  MemoryBuilder,
   MemoryService,
   ModelFallbackPlugin,
   models_exports as Models,
@@ -23531,6 +24064,7 @@ export {
   RecallMemoryTool,
   ReflectAndRetryToolPlugin,
   RougeEvaluator,
+  Run,
   RunConfig,
   Runner,
   SEMCONV,
@@ -23547,12 +24081,15 @@ export {
   tools_exports as Tools,
   TrajectoryEvaluator,
   TransferToAgentTool,
+  unified_memory_exports as UnifiedMemory,
   UserInteractionTool,
   VERSION,
   VectorStorageProvider,
   VertexAiSessionService,
   WebFetchTool,
   WebSearchTool,
+  Workflow,
+  workflows_exports as Workflows,
   WriteMemoryTool,
   WriteTool,
   _findFunctionCallEventIfLastEventIsFunctionResponse,
@@ -23576,7 +24113,10 @@ export {
   createPostgresSessionService,
   createSamplingHandler,
   createSqliteSessionService,
+  createStep,
   createTool,
+  createWorkflow,
+  defaultUnifiedMemoryConfig,
   extractTextFromContent,
   formatSpanAttributes,
   generateAuthEvent,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iqai/adk",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Agent Development Kit for TypeScript with multi-provider LLM support",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",