@iqai/adk 0.5.2 → 0.5.4

package/dist/index.mjs

@@ -3394,6 +3394,10 @@ var EventActions = class {
    * a compaction of events within the specified timestamp range.
    */
   compaction;
+  /**
+   * The invocation id to rewind to. This is only set for rewind event.
+   */
+  rewindBeforeInvocationId;
   /**
    * Constructor for EventActions
    */
@@ -3405,6 +3409,7 @@ var EventActions = class {
     this.escalate = options.escalate;
     this.requestedAuthConfigs = options.requestedAuthConfigs;
     this.compaction = options.compaction;
+    this.rewindBeforeInvocationId = options.rewindBeforeInvocationId;
   }
 };
 
@@ -4302,6 +4307,7 @@ __export(tools_exports, {
   McpNearAgent: () => McpNearAgent,
   McpNearIntents: () => McpNearIntents,
   McpOdos: () => McpOdos,
+  McpPolymarket: () => McpPolymarket,
   McpSamplingHandler: () => McpSamplingHandler,
   McpTelegram: () => McpTelegram,
   McpToolset: () => McpToolset,
@@ -6470,6 +6476,14 @@ function McpUpbit(config = {}) {
   );
   return new McpToolset(mcpConfig);
 }
+function McpPolymarket(config = {}) {
+  const mcpConfig = createMcpConfig(
+    "Polymarket MCP Client",
+    "@iqai/mcp-polymarket",
+    config
+  );
+  return new McpToolset(mcpConfig);
+}
 function McpFilesystem(config = {}) {
   const mcpConfig = createMcpConfig(
     "Filesystem MCP Client",
@@ -8468,8 +8482,30 @@ function rearrangeEventsForLatestFunctionResponse(events) {
   return resultEvents;
 }
 function getContents(currentBranch, events, agentName = "") {
+  const invocationIdToIndex = /* @__PURE__ */ new Map();
+  for (let idx = 0; idx < events.length; idx++) {
+    if (events[idx].invocationId) {
+      invocationIdToIndex.set(events[idx].invocationId, idx);
+    }
+  }
+  const rewindFilteredEvents = [];
+  let i = events.length - 1;
+  while (i >= 0) {
+    const event = events[i];
+    if (event.actions?.rewindBeforeInvocationId) {
+      const rewindInvocationId = event.actions.rewindBeforeInvocationId;
+      const rewindIndex = invocationIdToIndex.get(rewindInvocationId);
+      if (rewindIndex !== void 0 && rewindIndex < i) {
+        i = rewindIndex;
+      }
+    } else {
+      rewindFilteredEvents.push(event);
+    }
+    i--;
+  }
+  rewindFilteredEvents.reverse();
   const filteredEvents = [];
-  for (const event of events) {
+  for (const event of rewindFilteredEvents) {
     if (!event.content || !event.content.role || !event.content.parts || event.content.parts.length === 0) {
       continue;
     }
@@ -10184,6 +10220,48 @@ var RunConfig = class {
   }
 };
 
+// src/artifacts/artifact-util.ts
+var SESSION_SCOPED_ARTIFACT_URI_RE = /^artifact:\/\/apps\/([^/]+)\/users\/([^/]+)\/sessions\/([^/]+)\/artifacts\/([^/]+)\/versions\/(\d+)$/;
+var USER_SCOPED_ARTIFACT_URI_RE = /^artifact:\/\/apps\/([^/]+)\/users\/([^/]+)\/artifacts\/([^/]+)\/versions\/(\d+)$/;
+function parseArtifactUri(uri) {
+  if (!uri || !uri.startsWith("artifact://")) {
+    return null;
+  }
+  let match = SESSION_SCOPED_ARTIFACT_URI_RE.exec(uri);
+  if (match) {
+    return {
+      appName: match[1],
+      userId: match[2],
+      sessionId: match[3],
+      filename: match[4],
+      version: Number.parseInt(match[5], 10)
+    };
+  }
+  match = USER_SCOPED_ARTIFACT_URI_RE.exec(uri);
+  if (match) {
+    return {
+      appName: match[1],
+      userId: match[2],
+      sessionId: void 0,
+      filename: match[3],
+      version: Number.parseInt(match[4], 10)
+    };
+  }
+  return null;
+}
+function getArtifactUri(args) {
+  const { appName, userId, filename, version, sessionId } = args;
+  if (sessionId) {
+    return `artifact://apps/${appName}/users/${userId}/sessions/${sessionId}/artifacts/${filename}/versions/${version}`;
+  }
+  return `artifact://apps/${appName}/users/${userId}/artifacts/${filename}/versions/${version}`;
+}
+function isArtifactRef(artifact) {
+  return Boolean(
+    artifact.fileData?.fileUri && artifact.fileData.fileUri.startsWith("artifact://")
+  );
+}
+
 // src/artifacts/in-memory-artifact-service.ts
 var InMemoryArtifactService = class {
   artifacts = /* @__PURE__ */ new Map();
@@ -10224,7 +10302,29 @@ var InMemoryArtifactService = class {
     if (targetVersion < 0 || targetVersion >= versions.length) {
       return null;
     }
-    return versions[targetVersion];
+    const artifactEntry = versions[targetVersion];
+    if (!artifactEntry) {
+      return null;
+    }
+    if (isArtifactRef(artifactEntry)) {
+      const parsedUri = parseArtifactUri(artifactEntry.fileData?.fileUri || "");
+      if (!parsedUri) {
+        throw new Error(
+          `Invalid artifact reference URI: ${artifactEntry.fileData?.fileUri}`
+        );
+      }
+      return await this.loadArtifact({
+        appName: parsedUri.appName,
+        userId: parsedUri.userId,
+        sessionId: parsedUri.sessionId || sessionId,
+        filename: parsedUri.filename,
+        version: parsedUri.version
+      });
+    }
+    if (!artifactEntry.text && (!artifactEntry.inlineData?.data || artifactEntry.inlineData.data.length === 0) && !artifactEntry.fileData) {
+      return null;
+    }
+    return artifactEntry;
   }
   async listArtifactKeys(args) {
     const { appName, userId, sessionId } = args;
@@ -10409,11 +10509,16 @@ var BaseSessionService = class {
       return;
     }
     for (const key in event.actions.stateDelta) {
-      if (Object.prototype.hasOwnProperty.call(event.actions.stateDelta, key)) {
+      if (Object.hasOwn(event.actions.stateDelta, key)) {
         if (key.startsWith("temp_")) {
           continue;
         }
-        session.state[key] = event.actions.stateDelta[key];
+        const value = event.actions.stateDelta[key];
+        if (value === null || value === void 0) {
+          delete session.state[key];
+        } else {
+          session.state[key] = value;
+        }
       }
     }
   }
@@ -10961,6 +11066,142 @@ var Runner = class {
     }
     return void 0;
   }
+  async rewind(args) {
+    const { userId, sessionId, rewindBeforeInvocationId } = args;
+    const session = await this.sessionService.getSession(
+      this.appName,
+      userId,
+      sessionId
+    );
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    let rewindEventIndex = -1;
+    for (let i = 0; i < session.events.length; i++) {
+      if (session.events[i].invocationId === rewindBeforeInvocationId) {
+        rewindEventIndex = i;
+        break;
+      }
+    }
+    if (rewindEventIndex === -1) {
+      throw new Error(`Invocation ID not found: ${rewindBeforeInvocationId}`);
+    }
+    const stateDelta = await this._computeStateDeltaForRewind(
+      session,
+      rewindEventIndex
+    );
+    const artifactDelta = await this._computeArtifactDeltaForRewind(
+      session,
+      rewindEventIndex
+    );
+    const rewindEvent = new Event({
+      invocationId: newInvocationContextId(),
+      author: "user",
+      actions: new EventActions({
+        rewindBeforeInvocationId,
+        stateDelta,
+        artifactDelta
+      })
+    });
+    this.logger.info(
+      "Rewinding session to invocation:",
+      rewindBeforeInvocationId
+    );
+    await this.sessionService.appendEvent(session, rewindEvent);
+  }
+  async _computeStateDeltaForRewind(session, rewindEventIndex) {
+    const stateAtRewindPoint = {};
+    for (let i = 0; i < rewindEventIndex; i++) {
+      const event = session.events[i];
+      if (event.actions?.stateDelta) {
+        for (const [k, v] of Object.entries(event.actions.stateDelta)) {
+          if (k.startsWith("app:") || k.startsWith("user:")) {
+            continue;
+          }
+          if (v === null || v === void 0) {
+            delete stateAtRewindPoint[k];
+          } else {
+            stateAtRewindPoint[k] = v;
+          }
+        }
+      }
+    }
+    const currentState = session.state;
+    const rewindStateDelta = {};
+    for (const [key, valueAtRewind] of Object.entries(stateAtRewindPoint)) {
+      if (!(key in currentState) || currentState[key] !== valueAtRewind) {
+        rewindStateDelta[key] = valueAtRewind;
+      }
+    }
+    for (const key of Object.keys(currentState)) {
+      if (key.startsWith("app:") || key.startsWith("user:")) {
+        continue;
+      }
+      if (!(key in stateAtRewindPoint)) {
+        rewindStateDelta[key] = null;
+      }
+    }
+    return rewindStateDelta;
+  }
+  async _computeArtifactDeltaForRewind(session, rewindEventIndex) {
+    if (!this.artifactService) {
+      return {};
+    }
+    const versionsAtRewindPoint = {};
+    for (let i = 0; i < rewindEventIndex; i++) {
+      const event = session.events[i];
+      if (event.actions?.artifactDelta) {
+        Object.assign(versionsAtRewindPoint, event.actions.artifactDelta);
+      }
+    }
+    const currentVersions = {};
+    for (const event of session.events) {
+      if (event.actions?.artifactDelta) {
+        Object.assign(currentVersions, event.actions.artifactDelta);
+      }
+    }
+    const rewindArtifactDelta = {};
+    for (const [filename, vn] of Object.entries(currentVersions)) {
+      if (filename.startsWith("user:")) {
+        continue;
+      }
+      const vt = versionsAtRewindPoint[filename];
+      if (vt === vn) {
+        continue;
+      }
+      let artifact;
+      if (vt === void 0 || vt === null) {
+        artifact = {
+          inlineData: {
+            mimeType: "application/octet-stream",
+            data: ""
+          }
+        };
+      } else {
+        const artifactUri = getArtifactUri({
+          appName: this.appName,
+          userId: session.userId,
+          sessionId: session.id,
+          filename,
+          version: vt
+        });
+        artifact = {
+          fileData: {
+            fileUri: artifactUri
+          }
+        };
+      }
+      const newVersion = await this.artifactService.saveArtifact({
+        appName: this.appName,
+        userId: session.userId,
+        sessionId: session.id,
+        filename,
+        artifact
+      });
+      rewindArtifactDelta[filename] = newVersion;
+    }
+    return rewindArtifactDelta;
+  }
 };
 var InMemoryRunner = class extends Runner {
   /**
@@ -11664,6 +11905,9 @@ var AgentBuilder = class _AgentBuilder {
           ...params,
           runConfig: params.runConfig ?? runConfig
         });
+      },
+      rewind(params) {
+        return baseRunner.rewind(params);
       }
     };
   }
@@ -14204,6 +14448,7 @@ export {
   McpNearAgent,
   McpNearIntents,
   McpOdos,
+  McpPolymarket,
   McpSamplingHandler,
   McpTelegram,
   McpToolset,
@@ -14257,6 +14502,7 @@ export {
   createTool,
   generateAuthEvent,
   generateClientFunctionCallId,
+  getArtifactUri,
   getLongRunningFunctionCalls,
   getMcpTools,
   handleFunctionCallsAsync,
@@ -14265,6 +14511,7 @@ export {
   initializeTelemetry,
   injectSessionState,
   requestProcessor6 as instructionsRequestProcessor,
+  isArtifactRef,
   isEnhancedAuthConfig,
   jsonSchemaToDeclaration,
   mcpSchemaToParameters,
@@ -14274,6 +14521,7 @@ export {
   requestProcessor7 as nlPlanningRequestProcessor,
   responseProcessor2 as nlPlanningResponseProcessor,
   normalizeJsonSchema,
+  parseArtifactUri,
   populateClientFunctionCallId,
   registerProviders,
   removeClientFunctionCallId,

package/package.json

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