@iqai/adk 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -594,6 +594,7 @@ You could retry calling this tool, but it is IMPORTANT for you to provide all th
 var agents_exports = {};
 __export(agents_exports, {
   Agent: () => LlmAgent,
+  AgentBuilder: () => AgentBuilder,
   BaseAgent: () => BaseAgent,
   CallbackContext: () => CallbackContext,
   InvocationContext: () => InvocationContext,
@@ -8092,6 +8093,9 @@ var LangGraphAgent = class extends BaseAgent {
   }
 };
 
+// src/runners.ts
+import { SpanStatusCode } from "@opentelemetry/api";
+
 // src/agents/run-config.ts
 var StreamingMode = /* @__PURE__ */ ((StreamingMode2) => {
   StreamingMode2["NONE"] = "NONE";
@@ -8186,11 +8190,87 @@ var RunConfig = class {
   }
 };
 
-// src/memory/index.ts
-var memory_exports = {};
-__export(memory_exports, {
-  InMemoryMemoryService: () => InMemoryMemoryService
-});
+// src/artifacts/in-memory-artifact-service.ts
+init_logger();
+var logger9 = new Logger({ name: "InMemoryArtifactService" });
+var InMemoryArtifactService = class {
+  artifacts = /* @__PURE__ */ new Map();
+  fileHasUserNamespace(filename) {
+    return filename.startsWith("user:");
+  }
+  getArtifactPath(appName, userId, sessionId, filename) {
+    if (this.fileHasUserNamespace(filename)) {
+      return `${appName}/${userId}/user/${filename}`;
+    }
+    return `${appName}/${userId}/${sessionId}/${filename}`;
+  }
+  async saveArtifact(args) {
+    const { appName, userId, sessionId, filename, artifact } = args;
+    const path2 = this.getArtifactPath(appName, userId, sessionId, filename);
+    if (!this.artifacts.has(path2)) {
+      this.artifacts.set(path2, []);
+    }
+    const versions = this.artifacts.get(path2);
+    const version = versions.length;
+    versions.push(artifact);
+    return version;
+  }
+  async loadArtifact(args) {
+    const { appName, userId, sessionId, filename, version } = args;
+    const path2 = this.getArtifactPath(appName, userId, sessionId, filename);
+    const versions = this.artifacts.get(path2);
+    if (!versions || versions.length === 0) {
+      return null;
+    }
+    let targetVersion = version;
+    if (targetVersion === void 0 || targetVersion === null) {
+      targetVersion = versions.length - 1;
+    }
+    if (targetVersion < 0) {
+      targetVersion = versions.length + targetVersion;
+    }
+    if (targetVersion < 0 || targetVersion >= versions.length) {
+      return null;
+    }
+    return versions[targetVersion];
+  }
+  async listArtifactKeys(args) {
+    const { appName, userId, sessionId } = args;
+    const sessionPrefix = `${appName}/${userId}/${sessionId}/`;
+    const userNamespacePrefix = `${appName}/${userId}/user/`;
+    const filenames = [];
+    for (const path2 of this.artifacts.keys()) {
+      if (path2.startsWith(sessionPrefix)) {
+        const filename = path2.substring(sessionPrefix.length);
+        filenames.push(filename);
+      } else if (path2.startsWith(userNamespacePrefix)) {
+        const filename = path2.substring(userNamespacePrefix.length);
+        filenames.push(filename);
+      }
+    }
+    return filenames.sort();
+  }
+  async deleteArtifact(args) {
+    const { appName, userId, sessionId, filename } = args;
+    const path2 = this.getArtifactPath(appName, userId, sessionId, filename);
+    if (!this.artifacts.has(path2)) {
+      return;
+    }
+    this.artifacts.delete(path2);
+  }
+  async listVersions(args) {
+    const { appName, userId, sessionId, filename } = args;
+    const path2 = this.getArtifactPath(appName, userId, sessionId, filename);
+    const versions = this.artifacts.get(path2);
+    if (!versions || versions.length === 0) {
+      return [];
+    }
+    return Array.from({ length: versions.length }, (_, i) => i);
+  }
+};
+
+// src/runners.ts
+init_logger();
 
 // src/memory/_utils.ts
 function formatTimestamp(timestamp) {
@@ -8308,19 +8388,8 @@ var InMemoryMemoryService = class {
   }
 };
 
-// src/sessions/index.ts
-var sessions_exports = {};
-__export(sessions_exports, {
-  BaseSessionService: () => BaseSessionService,
-  DatabaseSessionService: () => DatabaseSessionService,
-  InMemorySessionService: () => InMemorySessionService,
-  State: () => State,
-  VertexAiSessionService: () => VertexAiSessionService,
-  createDatabaseSessionService: () => createDatabaseSessionService,
-  createMysqlSessionService: () => createMysqlSessionService,
-  createPostgresSessionService: () => createPostgresSessionService,
-  createSqliteSessionService: () => createSqliteSessionService
-});
+// src/sessions/in-memory-session-service.ts
+import { randomUUID } from "crypto";
 
 // src/sessions/base-session-service.ts
 var BaseSessionService = class {
@@ -8359,7 +8428,6 @@ var BaseSessionService = class {
 };
 
 // src/sessions/in-memory-session-service.ts
-import { randomUUID } from "crypto";
 var InMemorySessionService = class extends BaseSessionService {
   /**
    * A map from app name to a map from user ID to a map from session ID to session.
@@ -8571,1340 +8639,1541 @@ var InMemorySessionService = class extends BaseSessionService {
   }
 };
 
-// src/sessions/vertex-ai-session-service.ts
-var VertexAiSessionService = class extends BaseSessionService {
-  project;
-  location;
-  agentEngineId;
-  /**
-   * Initializes the VertexAiSessionService.
-   */
-  constructor(options = {}) {
-    super();
-    this.project = options.project;
-    this.location = options.location;
-    this.agentEngineId = options.agentEngineId;
-  }
-  async createSession(appName, userId, state, sessionId) {
-    if (sessionId) {
-      throw new Error(
-        "User-provided Session id is not supported for VertexAISessionService."
-      );
-    }
-    const reasoningEngineId = this.getReasoningEngineId(appName);
-    const apiClient = this.getApiClient();
-    const sessionJsonDict = { user_id: userId };
-    if (state) {
-      sessionJsonDict.session_state = state;
-    }
-    const apiResponse = await apiClient.async_request({
-      http_method: "POST",
-      path: `reasoningEngines/${reasoningEngineId}/sessions`,
-      request_dict: sessionJsonDict
-    });
-    console.info("Create Session response", apiResponse);
-    const createdSessionId = apiResponse.name.split("/").slice(-3, -2)[0];
-    const operationId = apiResponse.name.split("/").pop();
-    let maxRetryAttempt = 5;
-    let lroResponse = null;
-    while (maxRetryAttempt >= 0) {
-      lroResponse = await apiClient.async_request({
-        http_method: "GET",
-        path: `operations/${operationId}`,
-        request_dict: {}
-      });
-      if (lroResponse?.done) {
-        break;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 1e3));
-      maxRetryAttempt--;
-    }
-    if (!lroResponse || !lroResponse.done) {
-      throw new Error(
-        `Timeout waiting for operation ${operationId} to complete.`
-      );
-    }
-    const getSessionApiResponse = await apiClient.async_request({
-      http_method: "GET",
-      path: `reasoningEngines/${reasoningEngineId}/sessions/${createdSessionId}`,
-      request_dict: {}
-    });
-    const updateTimestamp = new Date(getSessionApiResponse.updateTime).getTime() / 1e3;
-    return {
-      appName: String(appName),
-      userId: String(userId),
-      id: String(createdSessionId),
-      state: getSessionApiResponse.sessionState || {},
-      events: [],
-      lastUpdateTime: updateTimestamp
-    };
+// src/runners.ts
+var logger10 = new Logger({ name: "Runner" });
+function _findFunctionCallEventIfLastEventIsFunctionResponse(session) {
+  const events = session.events;
+  if (!events || events.length === 0) {
+    return null;
   }
-  async getSession(appName, userId, sessionId, config) {
-    const reasoningEngineId = this.getReasoningEngineId(appName);
-    const apiClient = this.getApiClient();
-    try {
-      const getSessionApiResponse = await apiClient.async_request({
-        http_method: "GET",
-        path: `reasoningEngines/${reasoningEngineId}/sessions/${sessionId}`,
-        request_dict: {}
-      });
-      const sessionIdFromResponse = getSessionApiResponse.name.split("/").pop();
-      const updateTimestamp = new Date(getSessionApiResponse.updateTime).getTime() / 1e3;
-      const session = {
-        appName: String(appName),
-        userId: String(userId),
-        id: String(sessionIdFromResponse),
-        state: getSessionApiResponse.sessionState || {},
-        events: [],
-        lastUpdateTime: updateTimestamp
-      };
-      let listEventsApiResponse = await apiClient.async_request({
-        http_method: "GET",
-        path: `reasoningEngines/${reasoningEngineId}/sessions/${sessionId}/events`,
-        request_dict: {}
-      });
-      if (listEventsApiResponse.httpHeaders) {
-        return session;
-      }
-      if (listEventsApiResponse.sessionEvents) {
-        session.events.push(
-          ...listEventsApiResponse.sessionEvents.map(this.fromApiEvent)
-        );
-      }
-      while (listEventsApiResponse.nextPageToken) {
-        const pageToken = listEventsApiResponse.nextPageToken;
-        listEventsApiResponse = await apiClient.async_request({
-          http_method: "GET",
-          path: `reasoningEngines/${reasoningEngineId}/sessions/${sessionId}/events?pageToken=${encodeURIComponent(pageToken)}`,
-          request_dict: {}
-        });
-        if (listEventsApiResponse.sessionEvents) {
-          session.events.push(
-            ...listEventsApiResponse.sessionEvents.map(this.fromApiEvent)
-          );
-        }
-      }
-      session.events = session.events.filter(
-        (event) => event.timestamp <= updateTimestamp
-      );
-      session.events.sort((a, b) => a.timestamp - b.timestamp);
-      if (config) {
-        if (config.numRecentEvents) {
-          session.events = session.events.slice(-config.numRecentEvents);
-        } else if (config.afterTimestamp) {
-          let i = session.events.length - 1;
-          while (i >= 0) {
-            if (session.events[i].timestamp < config.afterTimestamp) {
-              break;
-            }
-            i--;
-          }
-          if (i >= 0) {
-            session.events = session.events.slice(i);
-          }
+  const lastEvent = events[events.length - 1];
+  if (lastEvent.content?.parts?.some((part) => part.functionResponse)) {
+    const functionCallId = lastEvent.content.parts.find(
+      (part) => part.functionResponse
+    )?.functionResponse?.id;
+    if (!functionCallId) return null;
+    for (let i = events.length - 2; i >= 0; i--) {
+      const event = events[i];
+      const functionCalls = event.getFunctionCalls?.() || [];
+      for (const functionCall of functionCalls) {
+        if (functionCall.id === functionCallId) {
+          return event;
         }
       }
-      return session;
-    } catch (error) {
-      console.error(`Error getting session ${sessionId}:`, error);
-      return void 0;
     }
   }
-  async listSessions(appName, userId) {
-    const reasoningEngineId = this.getReasoningEngineId(appName);
-    const apiClient = this.getApiClient();
-    let path2 = `reasoningEngines/${reasoningEngineId}/sessions`;
-    if (userId) {
-      const parsedUserId = encodeURIComponent(`"${userId}"`);
-      path2 = `${path2}?filter=user_id=${parsedUserId}`;
-    }
-    const apiResponse = await apiClient.async_request({
-      http_method: "GET",
-      path: path2,
-      request_dict: {}
-    });
-    if (apiResponse.httpHeaders) {
-      return { sessions: [] };
-    }
-    const sessions = [];
-    if (apiResponse.sessions) {
-      for (const apiSession of apiResponse.sessions) {
-        const session = {
-          appName,
+  return null;
+}
+var Runner = class {
+  /**
+   * The app name of the runner.
+   */
+  appName;
+  /**
+   * The root agent to run.
+   */
+  agent;
+  /**
+   * The artifact service for the runner.
+   */
+  artifactService;
+  /**
+   * The session service for the runner.
+   */
+  sessionService;
+  /**
+   * The memory service for the runner.
+   */
+  memoryService;
+  /**
+   * Initializes the Runner.
+   */
+  constructor({
+    appName,
+    agent,
+    artifactService,
+    sessionService,
+    memoryService
+  }) {
+    this.appName = appName;
+    this.agent = agent;
+    this.artifactService = artifactService;
+    this.sessionService = sessionService;
+    this.memoryService = memoryService;
+  }
+  /**
+   * Runs the agent synchronously.
+   * NOTE: This sync interface is only for local testing and convenience purpose.
+   * Consider using `runAsync` for production usage.
+   */
+  run({
+    userId,
+    sessionId,
+    newMessage,
+    runConfig = new RunConfig()
+  }) {
+    const eventQueue = [];
+    let queueIndex = 0;
+    let asyncCompleted = false;
+    const invokeRunAsync = async () => {
+      try {
+        for await (const event of this.runAsync({
           userId,
-          id: apiSession.name.split("/").pop(),
-          state: {},
-          events: [],
-          lastUpdateTime: new Date(apiSession.updateTime).getTime() / 1e3
-        };
-        sessions.push(session);
+          sessionId,
+          newMessage,
+          runConfig
+        })) {
+          eventQueue.push(event);
+        }
+      } finally {
+        eventQueue.push(null);
+        asyncCompleted = true;
       }
-    }
-    return { sessions };
+    };
+    invokeRunAsync();
+    return function* () {
+      while (true) {
+        while (queueIndex >= eventQueue.length && !asyncCompleted) {
+        }
+        if (queueIndex >= eventQueue.length && asyncCompleted) {
+          break;
+        }
+        const event = eventQueue[queueIndex++];
+        if (event === null) {
+          break;
+        }
+        yield event;
+      }
+    }();
   }
-  async deleteSession(appName, userId, sessionId) {
-    const reasoningEngineId = this.getReasoningEngineId(appName);
-    const apiClient = this.getApiClient();
+  /**
+   * Main entry method to run the agent in this runner.
+   */
+  async *runAsync({
+    userId,
+    sessionId,
+    newMessage,
+    runConfig = new RunConfig()
+  }) {
+    const span = tracer.startSpan("invocation");
     try {
-      await apiClient.async_request({
-        http_method: "DELETE",
-        path: `reasoningEngines/${reasoningEngineId}/sessions/${sessionId}`,
-        request_dict: {}
+      const session = await this.sessionService.getSession(
+        this.appName,
+        userId,
+        sessionId
+      );
+      if (!session) {
+        throw new Error(`Session not found: ${sessionId}`);
+      }
+      const invocationContext = this._newInvocationContext(session, {
+        newMessage,
+        runConfig
       });
+      if (newMessage) {
+        await this._appendNewMessageToSession(
+          session,
+          newMessage,
+          invocationContext,
+          runConfig.saveInputBlobsAsArtifacts || false
+        );
+      }
+      invocationContext.agent = this._findAgentToRun(session, this.agent);
+      for await (const event of invocationContext.agent.runAsync(
+        invocationContext
+      )) {
+        if (!event.partial) {
+          await this.sessionService.appendEvent(session, event);
+        }
+        yield event;
+      }
     } catch (error) {
-      console.error(`Error deleting session ${sessionId}:`, error);
+      logger10.debug("Error running agent:", error);
+      span.recordException(error);
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
       throw error;
+    } finally {
+      span.end();
     }
   }
-  async appendEvent(session, event) {
-    await super.appendEvent(session, event);
-    const reasoningEngineId = this.getReasoningEngineId(session.appName);
-    const apiClient = this.getApiClient();
-    await apiClient.async_request({
-      http_method: "POST",
-      path: `reasoningEngines/${reasoningEngineId}/sessions/${session.id}:appendEvent`,
-      request_dict: this.convertEventToJson(event)
+  /**
+   * Appends a new message to the session.
+   */
+  async _appendNewMessageToSession(session, newMessage, invocationContext, saveInputBlobsAsArtifacts = false) {
+    if (!newMessage.parts) {
+      throw new Error("No parts in the new_message.");
+    }
+    if (this.artifactService && saveInputBlobsAsArtifacts) {
+      for (let i = 0; i < newMessage.parts.length; i++) {
+        const part = newMessage.parts[i];
+        if (!part.inlineData) {
+          continue;
+        }
+        const fileName = `artifact_${invocationContext.invocationId}_${i}`;
+        await this.artifactService.saveArtifact({
+          appName: this.appName,
+          userId: session.userId,
+          sessionId: session.id,
+          filename: fileName,
+          artifact: part
+        });
+        newMessage.parts[i] = {
+          text: `Uploaded file: ${fileName}. It is saved into artifacts`
+        };
+      }
+    }
+    const userContent = {
+      ...newMessage,
+      role: "user"
+      // Ensure role is set for content filtering
+    };
+    const event = new Event({
+      invocationId: invocationContext.invocationId,
+      author: "user",
+      content: userContent
     });
-    return event;
+    await this.sessionService.appendEvent(session, event);
   }
-  getReasoningEngineId(appName) {
-    if (this.agentEngineId) {
-      return this.agentEngineId;
+  /**
+   * Finds the agent to run to continue the session.
+   */
+  _findAgentToRun(session, rootAgent) {
+    const event = _findFunctionCallEventIfLastEventIsFunctionResponse(session);
+    if (event?.author) {
+      return rootAgent.findAgent(event.author);
     }
-    if (/^\d+$/.test(appName)) {
-      return appName;
+    const nonUserEvents = session.events?.filter((e) => e.author !== "user").reverse() || [];
+    for (const event2 of nonUserEvents) {
+      if (event2.author === rootAgent.name) {
+        return rootAgent;
+      }
+      const agent = rootAgent.findSubAgent?.(event2.author);
+      if (!agent) {
+        logger10.debug(
+          `Event from an unknown agent: ${event2.author}, event id: ${event2.id}`
+        );
+        continue;
+      }
+      if (this._isTransferableAcrossAgentTree(agent)) {
+        return agent;
+      }
     }
-    const pattern = /^projects\/([a-zA-Z0-9-_]+)\/locations\/([a-zA-Z0-9-_]+)\/reasoningEngines\/(\d+)$/;
-    const match = appName.match(pattern);
-    if (!match) {
-      throw new Error(
-        `App name ${appName} is not valid. It should either be the full ReasoningEngine resource name, or the reasoning engine id.`
-      );
+    return rootAgent;
+  }
+  /**
+   * Whether the agent to run can transfer to any other agent in the agent tree.
+   */
+  _isTransferableAcrossAgentTree(agentToRun) {
+    let agent = agentToRun;
+    while (agent) {
+      if (!(agent instanceof LlmAgent)) {
+        return false;
+      }
+      if (agent.disallowTransferToParent) {
+        return false;
+      }
+      agent = agent.parentAgent || null;
     }
-    return match[3];
+    return true;
   }
-  getApiClient() {
-    const { GoogleGenAI: GoogleGenAI2 } = __require("@google/genai");
-    const client = new GoogleGenAI2({
-      vertexai: true,
-      project: this.project,
-      location: this.location
+  /**
+   * Creates a new invocation context.
+   */
+  _newInvocationContext(session, {
+    newMessage,
+    runConfig = new RunConfig()
+  }) {
+    const invocationId = newInvocationContextId();
+    return new InvocationContext({
+      artifactService: this.artifactService,
+      sessionService: this.sessionService,
+      memoryService: this.memoryService,
+      invocationId,
+      agent: this.agent,
+      session,
+      userContent: newMessage || null,
+      liveRequestQueue: null,
+      runConfig
     });
-    return client._api_client;
-  }
-  convertEventToJson(event) {
-    const metadataJson = {
-      partial: event.partial,
-      turn_complete: event.turnComplete,
-      interrupted: event.interrupted,
-      branch: event.branch,
-      long_running_tool_ids: event.longRunningToolIds ? Array.from(event.longRunningToolIds) : null
-    };
-    if (event.groundingMetadata) {
-      metadataJson.grounding_metadata = event.groundingMetadata;
-    }
-    const eventJson = {
-      author: event.author,
-      invocation_id: event.invocationId,
-      timestamp: {
-        seconds: Math.floor(event.timestamp),
-        nanos: Math.floor(
-          (event.timestamp - Math.floor(event.timestamp)) * 1e9
-        )
-      },
-      error_code: event.errorCode,
-      error_message: event.errorMessage,
-      event_metadata: metadataJson
-    };
-    if (event.actions) {
-      const actionsJson = {
-        skip_summarization: event.actions.skipSummarization,
-        state_delta: event.actions.stateDelta,
-        artifact_delta: event.actions.artifactDelta,
-        transfer_agent: event.actions.transferToAgent,
-        escalate: event.actions.escalate,
-        requested_auth_configs: event.actions.requestedAuthConfigs
-      };
-      eventJson.actions = actionsJson;
-    }
-    if (event.content) {
-      eventJson.content = event.content;
-    }
-    return eventJson;
   }
-  fromApiEvent(apiEvent) {
-    let eventActions = new EventActions();
-    if (apiEvent.actions) {
-      eventActions = new EventActions({
-        skipSummarization: apiEvent.actions.skipSummarization,
-        stateDelta: apiEvent.actions.stateDelta || {},
-        artifactDelta: apiEvent.actions.artifactDelta || {},
-        transferToAgent: apiEvent.actions.transferAgent,
-        escalate: apiEvent.actions.escalate,
-        requestedAuthConfigs: apiEvent.actions.requestedAuthConfigs || {}
-      });
-    }
-    const event = new Event({
-      id: apiEvent.name.split("/").pop(),
-      invocationId: apiEvent.invocationId,
-      author: apiEvent.author,
-      actions: eventActions,
-      content: this.decodeContent(apiEvent.content),
-      timestamp: new Date(apiEvent.timestamp).getTime() / 1e3
+};
+var InMemoryRunner = class extends Runner {
+  /**
+   * Deprecated. Please don't use. The in-memory session service for the runner.
+   */
+  _inMemorySessionService;
+  /**
+   * Initializes the InMemoryRunner.
+   */
+  constructor(agent, { appName = "InMemoryRunner" } = {}) {
+    const inMemorySessionService = new InMemorySessionService();
+    super({
+      appName,
+      agent,
+      artifactService: new InMemoryArtifactService(),
+      sessionService: inMemorySessionService,
+      memoryService: new InMemoryMemoryService()
     });
-    if (apiEvent.errorCode) {
-      event.errorCode = apiEvent.errorCode;
-    }
-    if (apiEvent.errorMessage) {
-      event.errorMessage = apiEvent.errorMessage;
-    }
-    if (apiEvent.eventMetadata) {
-      const longRunningToolIdsList = apiEvent.eventMetadata.longRunningToolIds;
-      event.partial = apiEvent.eventMetadata.partial;
-      event.turnComplete = apiEvent.eventMetadata.turnComplete;
-      event.interrupted = apiEvent.eventMetadata.interrupted;
-      event.branch = apiEvent.eventMetadata.branch;
-      event.groundingMetadata = this.decodeGroundingMetadata(
-        apiEvent.eventMetadata.groundingMetadata
-      );
-      event.longRunningToolIds = longRunningToolIdsList ? new Set(longRunningToolIdsList) : void 0;
-    }
-    return event;
-  }
-  decodeContent(content) {
-    if (!content) return void 0;
-    return content;
-  }
-  decodeGroundingMetadata(groundingMetadata) {
-    if (!groundingMetadata) return void 0;
-    return groundingMetadata;
+    this._inMemorySessionService = inMemorySessionService;
   }
 };
 
-// src/sessions/database-session-service.ts
-import { sql } from "kysely";
-var DatabaseSessionService = class extends BaseSessionService {
-  db;
-  initialized = false;
-  constructor(config) {
-    super();
-    this.db = config.db;
-    if (!config.skipTableCreation) {
-      this.initializeDatabase().catch((error) => {
-        console.error("Failed to initialize database:", error);
-      });
-    }
+// src/agents/agent-builder.ts
+var AgentBuilder = class _AgentBuilder {
+  config;
+  sessionConfig;
+  agentType = "llm";
+  /**
+   * Private constructor - use static create() method
+   */
+  constructor(name) {
+    this.config = { name };
   }
   /**
-   * Initialize the database by creating required tables if they don't exist
+   * Create a new AgentBuilder instance
+   * @param name The name of the agent (defaults to "default_agent")
+   * @returns New AgentBuilder instance
    */
-  async initializeDatabase() {
-    if (this.initialized) {
-      return;
-    }
-    try {
-      await this.db.schema.createTable("sessions").ifNotExists().addColumn("id", "varchar(128)", (col) => col.notNull()).addColumn("app_name", "varchar(128)", (col) => col.notNull()).addColumn("user_id", "varchar(128)", (col) => col.notNull()).addColumn("state", "text", (col) => col.defaultTo("{}")).addColumn(
-        "create_time",
-        "timestamp",
-        (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      ).addColumn(
-        "update_time",
-        "timestamp",
-        (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      ).addPrimaryKeyConstraint("sessions_pk", ["app_name", "user_id", "id"]).execute();
-      await this.db.schema.createTable("events").ifNotExists().addColumn("id", "varchar(128)", (col) => col.notNull()).addColumn("app_name", "varchar(128)", (col) => col.notNull()).addColumn("user_id", "varchar(128)", (col) => col.notNull()).addColumn("session_id", "varchar(128)", (col) => col.notNull()).addColumn("invocation_id", "varchar(256)").addColumn("author", "varchar(256)").addColumn("branch", "varchar(256)").addColumn(
-        "timestamp",
-        "timestamp",
-        (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`)
-      ).addColumn("content", "text").addColumn("actions", "text").addColumn("long_running_tool_ids_json", "text").addColumn("grounding_metadata", "text").addColumn("partial", "boolean").addColumn("turn_complete", "boolean").addColumn("error_code", "varchar(256)").addColumn("error_message", "varchar(1024)").addColumn("interrupted", "boolean").addPrimaryKeyConstraint("events_pk", [
-        "id",
-        "app_name",
-        "user_id",
-        "session_id"
-      ]).addForeignKeyConstraint(
-        "events_session_fk",
-        ["app_name", "user_id", "session_id"],
-        "sessions",
-        ["app_name", "user_id", "id"]
-      ).execute();
-      await this.db.schema.createTable("app_states").ifNotExists().addColumn("app_name", "varchar(128)", (col) => col.primaryKey()).addColumn("state", "text", (col) => col.defaultTo("{}")).addColumn(
-        "update_time",
-        "timestamp",
-        (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      ).execute();
-      await this.db.schema.createTable("user_states").ifNotExists().addColumn("app_name", "varchar(128)", (col) => col.notNull()).addColumn("user_id", "varchar(128)", (col) => col.notNull()).addColumn("state", "text", (col) => col.defaultTo("{}")).addColumn(
-        "update_time",
-        "timestamp",
-        (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
-      ).addPrimaryKeyConstraint("user_states_pk", ["app_name", "user_id"]).execute();
-      await this.db.schema.createIndex("idx_sessions_user_id").ifNotExists().on("sessions").column("user_id").execute();
-      this.initialized = true;
-    } catch (error) {
-      console.error("Error initializing database:", error);
-      throw error;
-    }
+  static create(name = "default_agent") {
+    return new _AgentBuilder(name);
   }
   /**
-   * Ensure database is initialized before any operation
+   * Convenience method to start building with a model directly
+   * @param model The model identifier (e.g., "gemini-2.5-flash")
+   * @returns New AgentBuilder instance with model set
    */
-  async ensureInitialized() {
-    if (!this.initialized) {
-      await this.initializeDatabase();
-    }
+  static withModel(model) {
+    return new _AgentBuilder("default_agent").withModel(model);
   }
-  generateSessionId() {
-    return `session-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  /**
+   * Set the model for the agent
+   * @param model The model identifier (e.g., "gemini-2.5-flash")
+   * @returns This builder instance for chaining
+   */
+  withModel(model) {
+    this.config.model = model;
+    return this;
   }
   /**
-   * Helper to safely parse JSON strings
+   * Set the description for the agent
+   * @param description Agent description
+   * @returns This builder instance for chaining
    */
-  parseJsonSafely(jsonString, defaultValue) {
-    if (!jsonString) return defaultValue;
-    try {
-      return JSON.parse(jsonString);
-    } catch {
-      return defaultValue;
+  withDescription(description) {
+    this.config.description = description;
+    return this;
+  }
+  /**
+   * Set the instruction for the agent
+   * @param instruction System instruction for the agent
+   * @returns This builder instance for chaining
+   */
+  withInstruction(instruction) {
+    this.config.instruction = instruction;
+    return this;
+  }
+  /**
+   * Add tools to the agent
+   * @param tools Tools to add to the agent
+   * @returns This builder instance for chaining
+   */
+  withTools(...tools) {
+    this.config.tools = [...this.config.tools || [], ...tools];
+    return this;
+  }
+  /**
+   * Set the planner for the agent
+   * @param planner The planner to use
+   * @returns This builder instance for chaining
+   */
+  withPlanner(planner) {
+    this.config.planner = planner;
+    return this;
+  }
+  /**
+   * Configure as a sequential agent
+   * @param subAgents Sub-agents to execute in sequence
+   * @returns This builder instance for chaining
+   */
+  asSequential(subAgents) {
+    this.agentType = "sequential";
+    this.config.subAgents = subAgents;
+    return this;
+  }
+  /**
+   * Configure as a parallel agent
+   * @param subAgents Sub-agents to execute in parallel
+   * @returns This builder instance for chaining
+   */
+  asParallel(subAgents) {
+    this.agentType = "parallel";
+    this.config.subAgents = subAgents;
+    return this;
+  }
+  /**
+   * Configure as a loop agent
+   * @param subAgents Sub-agents to execute iteratively
+   * @param maxIterations Maximum number of iterations
+   * @returns This builder instance for chaining
+   */
+  asLoop(subAgents, maxIterations = 3) {
+    this.agentType = "loop";
+    this.config.subAgents = subAgents;
+    this.config.maxIterations = maxIterations;
+    return this;
+  }
+  /**
+   * Configure as a LangGraph agent
+   * @param nodes Graph nodes defining the workflow
+   * @param rootNode The starting node name
+   * @returns This builder instance for chaining
+   */
+  asLangGraph(nodes, rootNode) {
+    this.agentType = "langgraph";
+    this.config.nodes = nodes;
+    this.config.rootNode = rootNode;
+    return this;
+  }
+  /**
+   * Configure session management
+   * @param service Session service to use
+   * @param userId User identifier
+   * @param appName Application name
+   * @param memoryService Optional memory service
+   * @param artifactService Optional artifact service
+   * @returns This builder instance for chaining
+   */
+  withSession(service, userId, appName, memoryService, artifactService) {
+    this.sessionConfig = {
+      service,
+      userId,
+      appName,
+      memoryService,
+      artifactService
+    };
+    return this;
+  }
+  /**
+   * Configure with an in-memory session (for quick setup)
+   * @param appName Application name
+   * @param userId User identifier
+   * @returns This builder instance for chaining
+   */
+  withQuickSession(appName, userId) {
+    return this.withSession(new InMemorySessionService(), userId, appName);
+  }
+  /**
+   * Build the agent and optionally create runner and session
+   * @returns Built agent with optional runner and session
+   */
+  async build() {
+    const agent = this.createAgent();
+    let runner;
+    let session;
+    if (this.sessionConfig) {
+      session = await this.sessionConfig.service.createSession(
+        this.sessionConfig.appName,
+        this.sessionConfig.userId
+      );
+      const runnerConfig = {
+        appName: this.sessionConfig.appName,
+        agent,
+        sessionService: this.sessionConfig.service
+      };
+      if (this.sessionConfig.memoryService) {
+        runnerConfig.memoryService = this.sessionConfig.memoryService;
+      }
+      if (this.sessionConfig.artifactService) {
+        runnerConfig.artifactService = this.sessionConfig.artifactService;
+      }
+      runner = new Runner(runnerConfig);
     }
+    return { agent, runner, session };
   }
   /**
-   * Convert database timestamp to Unix seconds
-   * Handles different timestamp formats from different databases
+   * Quick execution helper - build and run a message
+   * @param message Message to send to the agent
+   * @returns Agent response
    */
-  timestampToUnixSeconds(timestamp) {
-    if (timestamp instanceof Date) {
-      return timestamp.getTime() / 1e3;
+  async ask(message) {
+    if (!this.sessionConfig) {
+      const userId = `user-${this.config.name}`;
+      const appName = `session-${this.config.name}`;
+      this.withQuickSession(appName, userId);
     }
-    if (typeof timestamp === "string") {
-      return new Date(timestamp).getTime() / 1e3;
+    const { runner, session } = await this.build();
+    if (!runner || !session) {
+      throw new Error("Failed to create runner and session");
     }
-    if (typeof timestamp === "number") {
-      return timestamp > 1e10 ? timestamp / 1e3 : timestamp;
+    let response = "";
+    for await (const event of runner.runAsync({
+      userId: this.sessionConfig.userId,
+      sessionId: session.id,
+      newMessage: {
+        parts: [{ text: message }]
+      }
+    })) {
+      if (event.content?.parts) {
+        const content = event.content.parts.map((part) => part.text || "").join("");
+        if (content) {
+          response += content;
+        }
+      }
     }
-    return Date.now() / 1e3;
+    return response;
+  }
+  /**
+   * Create the appropriate agent type based on configuration
+   * @returns Created agent instance
+   */
+  createAgent() {
+    switch (this.agentType) {
+      case "sequential":
+        if (!this.config.subAgents) {
+          throw new Error("Sub-agents required for sequential agent");
+        }
+        return new SequentialAgent({
+          name: this.config.name,
+          description: this.config.description || "",
+          subAgents: this.config.subAgents
+        });
+      case "parallel":
+        if (!this.config.subAgents) {
+          throw new Error("Sub-agents required for parallel agent");
+        }
+        return new ParallelAgent({
+          name: this.config.name,
+          description: this.config.description || "",
+          subAgents: this.config.subAgents
+        });
+      case "loop":
+        if (!this.config.subAgents) {
+          throw new Error("Sub-agents required for loop agent");
+        }
+        return new LoopAgent({
+          name: this.config.name,
+          description: this.config.description || "",
+          subAgents: this.config.subAgents,
+          maxIterations: this.config.maxIterations || 3
+        });
+      case "langgraph":
+        if (!this.config.nodes || !this.config.rootNode) {
+          throw new Error("Nodes and root node required for LangGraph agent");
+        }
+        return new LangGraphAgent({
+          name: this.config.name,
+          description: this.config.description || "",
+          nodes: this.config.nodes,
+          rootNode: this.config.rootNode
+        });
+      default:
+        return new LlmAgent({
+          name: this.config.name,
+          model: this.config.model,
+          description: this.config.description,
+          instruction: this.config.instruction,
+          tools: this.config.tools,
+          planner: this.config.planner
+        });
+    }
+  }
+};
+
+// src/memory/index.ts
+var memory_exports = {};
+__export(memory_exports, {
+  InMemoryMemoryService: () => InMemoryMemoryService
+});
+
+// src/sessions/index.ts
+var sessions_exports = {};
+__export(sessions_exports, {
+  BaseSessionService: () => BaseSessionService,
+  DatabaseSessionService: () => DatabaseSessionService,
+  InMemorySessionService: () => InMemorySessionService,
+  State: () => State,
+  VertexAiSessionService: () => VertexAiSessionService,
+  createDatabaseSessionService: () => createDatabaseSessionService,
+  createMysqlSessionService: () => createMysqlSessionService,
+  createPostgresSessionService: () => createPostgresSessionService,
+  createSqliteSessionService: () => createSqliteSessionService
+});
+
+// src/sessions/vertex-ai-session-service.ts
+var VertexAiSessionService = class extends BaseSessionService {
+  project;
+  location;
+  agentEngineId;
+  /**
+   * Initializes the VertexAiSessionService.
+   */
+  constructor(options = {}) {
+    super();
+    this.project = options.project;
+    this.location = options.location;
+    this.agentEngineId = options.agentEngineId;
   }
   async createSession(appName, userId, state, sessionId) {
-    await this.ensureInitialized();
-    const id = sessionId?.trim() || this.generateSessionId();
-    return await this.db.transaction().execute(async (trx) => {
-      const appState = await trx.selectFrom("app_states").selectAll().where("app_name", "=", appName).executeTakeFirst();
-      const userState = await trx.selectFrom("user_states").selectAll().where("app_name", "=", appName).where("user_id", "=", userId).executeTakeFirst();
-      let currentAppState = this.parseJsonSafely(appState?.state, {});
-      let currentUserState = this.parseJsonSafely(userState?.state, {});
-      if (!appState) {
-        await trx.insertInto("app_states").values({
-          app_name: appName,
-          state: "{}"
-        }).execute();
-      }
-      if (!userState) {
-        await trx.insertInto("user_states").values({
-          app_name: appName,
-          user_id: userId,
-          state: "{}"
-        }).execute();
-      }
-      const { appStateDelta, userStateDelta, sessionStateDelta } = this.extractStateDelta(state);
-      currentAppState = { ...currentAppState, ...appStateDelta };
-      currentUserState = { ...currentUserState, ...userStateDelta };
-      if (Object.keys(appStateDelta).length > 0) {
-        await trx.updateTable("app_states").set({
-          state: JSON.stringify(currentAppState),
-          update_time: sql`CURRENT_TIMESTAMP`
-        }).where("app_name", "=", appName).execute();
-      }
-      if (Object.keys(userStateDelta).length > 0) {
-        await trx.updateTable("user_states").set({
-          state: JSON.stringify(currentUserState),
-          update_time: sql`CURRENT_TIMESTAMP`
-        }).where("app_name", "=", appName).where("user_id", "=", userId).execute();
+    if (sessionId) {
+      throw new Error(
+        "User-provided Session id is not supported for VertexAISessionService."
+      );
+    }
+    const reasoningEngineId = this.getReasoningEngineId(appName);
+    const apiClient = this.getApiClient();
+    const sessionJsonDict = { user_id: userId };
+    if (state) {
+      sessionJsonDict.session_state = state;
+    }
+    const apiResponse = await apiClient.async_request({
+      http_method: "POST",
+      path: `reasoningEngines/${reasoningEngineId}/sessions`,
+      request_dict: sessionJsonDict
+    });
+    console.info("Create Session response", apiResponse);
+    const createdSessionId = apiResponse.name.split("/").slice(-3, -2)[0];
+    const operationId = apiResponse.name.split("/").pop();
+    let maxRetryAttempt = 5;
+    let lroResponse = null;
+    while (maxRetryAttempt >= 0) {
+      lroResponse = await apiClient.async_request({
+        http_method: "GET",
+        path: `operations/${operationId}`,
+        request_dict: {}
+      });
+      if (lroResponse?.done) {
+        break;
       }
-      const result = await trx.insertInto("sessions").values({
-        id,
-        app_name: appName,
-        user_id: userId,
-        state: JSON.stringify(sessionStateDelta)
-      }).returningAll().executeTakeFirstOrThrow();
-      const mergedState = this.mergeState(
-        currentAppState,
-        currentUserState,
-        sessionStateDelta
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      maxRetryAttempt--;
+    }
+    if (!lroResponse || !lroResponse.done) {
+      throw new Error(
+        `Timeout waiting for operation ${operationId} to complete.`
       );
-      return {
-        id: result.id,
-        appName: result.app_name,
-        userId: result.user_id,
-        state: mergedState,
-        events: [],
-        // Fixed type annotation
-        lastUpdateTime: this.timestampToUnixSeconds(result.update_time)
-      };
+    }
+    const getSessionApiResponse = await apiClient.async_request({
+      http_method: "GET",
+      path: `reasoningEngines/${reasoningEngineId}/sessions/${createdSessionId}`,
+      request_dict: {}
     });
+    const updateTimestamp = new Date(getSessionApiResponse.updateTime).getTime() / 1e3;
+    return {
+      appName: String(appName),
+      userId: String(userId),
+      id: String(createdSessionId),
+      state: getSessionApiResponse.sessionState || {},
+      events: [],
+      lastUpdateTime: updateTimestamp
+    };
   }
   async getSession(appName, userId, sessionId, config) {
-    await this.ensureInitialized();
-    return await this.db.transaction().execute(async (trx) => {
-      const storageSession = await trx.selectFrom("sessions").selectAll().where("app_name", "=", appName).where("user_id", "=", userId).where("id", "=", sessionId).executeTakeFirst();
-      if (!storageSession) {
-        return void 0;
+    const reasoningEngineId = this.getReasoningEngineId(appName);
+    const apiClient = this.getApiClient();
+    try {
+      const getSessionApiResponse = await apiClient.async_request({
+        http_method: "GET",
+        path: `reasoningEngines/${reasoningEngineId}/sessions/${sessionId}`,
+        request_dict: {}
+      });
+      const sessionIdFromResponse = getSessionApiResponse.name.split("/").pop();
+      const updateTimestamp = new Date(getSessionApiResponse.updateTime).getTime() / 1e3;
+      const session = {
+        appName: String(appName),
+        userId: String(userId),
+        id: String(sessionIdFromResponse),
+        state: getSessionApiResponse.sessionState || {},
+        events: [],
+        lastUpdateTime: updateTimestamp
+      };
+      let listEventsApiResponse = await apiClient.async_request({
+        http_method: "GET",
+        path: `reasoningEngines/${reasoningEngineId}/sessions/${sessionId}/events`,
+        request_dict: {}
+      });
+      if (listEventsApiResponse.httpHeaders) {
+        return session;
       }
-      let eventQuery = trx.selectFrom("events").selectAll().where("session_id", "=", sessionId).orderBy("timestamp", "desc");
-      if (config?.afterTimestamp) {
-        eventQuery = eventQuery.where(
-          "timestamp",
-          ">=",
-          new Date(config.afterTimestamp * 1e3)
+      if (listEventsApiResponse.sessionEvents) {
+        session.events.push(
+          ...listEventsApiResponse.sessionEvents.map(this.fromApiEvent)
         );
       }
-      if (config?.numRecentEvents) {
-        eventQuery = eventQuery.limit(config.numRecentEvents);
+      while (listEventsApiResponse.nextPageToken) {
+        const pageToken = listEventsApiResponse.nextPageToken;
+        listEventsApiResponse = await apiClient.async_request({
+          http_method: "GET",
+          path: `reasoningEngines/${reasoningEngineId}/sessions/${sessionId}/events?pageToken=${encodeURIComponent(pageToken)}`,
+          request_dict: {}
+        });
+        if (listEventsApiResponse.sessionEvents) {
+          session.events.push(
+            ...listEventsApiResponse.sessionEvents.map(this.fromApiEvent)
+          );
+        }
       }
-      const storageEvents = await eventQuery.execute();
-      const appState = await trx.selectFrom("app_states").selectAll().where("app_name", "=", appName).executeTakeFirst();
-      const userState = await trx.selectFrom("user_states").selectAll().where("app_name", "=", appName).where("user_id", "=", userId).executeTakeFirst();
-      const currentAppState = this.parseJsonSafely(appState?.state, {});
-      const currentUserState = this.parseJsonSafely(userState?.state, {});
-      const sessionState = this.parseJsonSafely(storageSession.state, {});
-      const mergedState = this.mergeState(
-        currentAppState,
-        currentUserState,
-        sessionState
+      session.events = session.events.filter(
+        (event) => event.timestamp <= updateTimestamp
       );
-      const events = storageEvents.reverse().map((storageEvent) => this.storageEventToEvent(storageEvent));
-      return {
-        id: sessionId,
-        appName,
-        userId,
-        state: mergedState,
-        events,
-        // Now properly typed as Event[]
-        lastUpdateTime: this.timestampToUnixSeconds(storageSession.update_time)
-      };
-    });
-  }
-  async updateSession(session) {
-    await this.ensureInitialized();
-    await this.db.updateTable("sessions").set({
-      state: JSON.stringify(session.state),
-      update_time: sql`CURRENT_TIMESTAMP`
-    }).where("app_name", "=", session.appName).where("user_id", "=", session.userId).where("id", "=", session.id).execute();
+      session.events.sort((a, b) => a.timestamp - b.timestamp);
+      if (config) {
+        if (config.numRecentEvents) {
+          session.events = session.events.slice(-config.numRecentEvents);
+        } else if (config.afterTimestamp) {
+          let i = session.events.length - 1;
+          while (i >= 0) {
+            if (session.events[i].timestamp < config.afterTimestamp) {
+              break;
+            }
+            i--;
+          }
+          if (i >= 0) {
+            session.events = session.events.slice(i);
+          }
+        }
+      }
+      return session;
+    } catch (error) {
+      console.error(`Error getting session ${sessionId}:`, error);
+      return void 0;
+    }
   }
   async listSessions(appName, userId) {
-    await this.ensureInitialized();
-    const results = await this.db.selectFrom("sessions").selectAll().where("app_name", "=", appName).where("user_id", "=", userId).execute();
-    const sessions = results.map((storageSession) => ({
-      id: storageSession.id,
-      appName: storageSession.app_name,
-      userId: storageSession.user_id,
-      state: {},
-      events: [],
-      // Fixed type annotation
-      lastUpdateTime: this.timestampToUnixSeconds(storageSession.update_time)
-    }));
+    const reasoningEngineId = this.getReasoningEngineId(appName);
+    const apiClient = this.getApiClient();
+    let path2 = `reasoningEngines/${reasoningEngineId}/sessions`;
+    if (userId) {
+      const parsedUserId = encodeURIComponent(`"${userId}"`);
+      path2 = `${path2}?filter=user_id=${parsedUserId}`;
+    }
+    const apiResponse = await apiClient.async_request({
+      http_method: "GET",
+      path: path2,
+      request_dict: {}
+    });
+    if (apiResponse.httpHeaders) {
+      return { sessions: [] };
+    }
+    const sessions = [];
+    if (apiResponse.sessions) {
+      for (const apiSession of apiResponse.sessions) {
+        const session = {
+          appName,
+          userId,
+          id: apiSession.name.split("/").pop(),
+          state: {},
+          events: [],
+          lastUpdateTime: new Date(apiSession.updateTime).getTime() / 1e3
+        };
+        sessions.push(session);
+      }
+    }
     return { sessions };
   }
   async deleteSession(appName, userId, sessionId) {
-    await this.ensureInitialized();
-    await this.db.deleteFrom("sessions").where("app_name", "=", appName).where("user_id", "=", userId).where("id", "=", sessionId).execute();
+    const reasoningEngineId = this.getReasoningEngineId(appName);
+    const apiClient = this.getApiClient();
+    try {
+      await apiClient.async_request({
+        http_method: "DELETE",
+        path: `reasoningEngines/${reasoningEngineId}/sessions/${sessionId}`,
+        request_dict: {}
+      });
+    } catch (error) {
+      console.error(`Error deleting session ${sessionId}:`, error);
+      throw error;
+    }
   }
   async appendEvent(session, event) {
-    await this.ensureInitialized();
-    if (event.partial) {
-      return event;
-    }
-    return await this.db.transaction().execute(async (trx) => {
-      const storageSession = await trx.selectFrom("sessions").selectAll().where("app_name", "=", session.appName).where("user_id", "=", session.userId).where("id", "=", session.id).executeTakeFirstOrThrow();
-      if (this.timestampToUnixSeconds(storageSession.update_time) > session.lastUpdateTime) {
-        throw new Error(
-          `The last_update_time provided in the session object ${new Date(session.lastUpdateTime * 1e3).toISOString()} is earlier than the update_time in the storage_session ${storageSession.update_time.toISOString()}. Please check if it is a stale session.`
-        );
-      }
-      const appState = await trx.selectFrom("app_states").selectAll().where("app_name", "=", session.appName).executeTakeFirst();
-      const userState = await trx.selectFrom("user_states").selectAll().where("app_name", "=", session.appName).where("user_id", "=", session.userId).executeTakeFirst();
-      let currentAppState = this.parseJsonSafely(appState?.state, {});
-      let currentUserState = this.parseJsonSafely(userState?.state, {});
-      let sessionState = this.parseJsonSafely(storageSession.state, {});
-      let appStateDelta = {};
-      let userStateDelta = {};
-      let sessionStateDelta = {};
-      if (event.actions?.stateDelta) {
-        const deltas = this.extractStateDelta(event.actions.stateDelta);
-        appStateDelta = deltas.appStateDelta;
-        userStateDelta = deltas.userStateDelta;
-        sessionStateDelta = deltas.sessionStateDelta;
-      }
-      if (Object.keys(appStateDelta).length > 0) {
-        currentAppState = { ...currentAppState, ...appStateDelta };
-        await trx.updateTable("app_states").set({
-          state: JSON.stringify(currentAppState),
-          update_time: sql`CURRENT_TIMESTAMP`
-        }).where("app_name", "=", session.appName).execute();
-      }
-      if (Object.keys(userStateDelta).length > 0) {
-        currentUserState = { ...currentUserState, ...userStateDelta };
-        await trx.updateTable("user_states").set({
-          state: JSON.stringify(currentUserState),
-          update_time: sql`CURRENT_TIMESTAMP`
-        }).where("app_name", "=", session.appName).where("user_id", "=", session.userId).execute();
-      }
-      if (Object.keys(sessionStateDelta).length > 0) {
-        sessionState = { ...sessionState, ...sessionStateDelta };
-        await trx.updateTable("sessions").set({
-          state: JSON.stringify(sessionState),
-          update_time: sql`CURRENT_TIMESTAMP`
-        }).where("app_name", "=", session.appName).where("user_id", "=", session.userId).where("id", "=", session.id).execute();
-      }
-      await trx.insertInto("events").values({
-        ...this.eventToStorageEvent(session, event),
-        timestamp: sql`CURRENT_TIMESTAMP`
-      }).execute();
-      const updatedSession = await trx.selectFrom("sessions").select("update_time").where("app_name", "=", session.appName).where("user_id", "=", session.userId).where("id", "=", session.id).executeTakeFirstOrThrow();
-      session.lastUpdateTime = this.timestampToUnixSeconds(
-        updatedSession.update_time
-      );
-      super.appendEvent(session, event);
-      return event;
+    await super.appendEvent(session, event);
+    const reasoningEngineId = this.getReasoningEngineId(session.appName);
+    const apiClient = this.getApiClient();
+    await apiClient.async_request({
+      http_method: "POST",
+      path: `reasoningEngines/${reasoningEngineId}/sessions/${session.id}:appendEvent`,
+      request_dict: this.convertEventToJson(event)
     });
+    return event;
   }
-  /**
-   * Extract state deltas based on prefixes (similar to Python implementation)
-   */
-  extractStateDelta(state) {
-    const appStateDelta = {};
-    const userStateDelta = {};
-    const sessionStateDelta = {};
-    if (state) {
-      for (const [key, value] of Object.entries(state)) {
-        if (key.startsWith("app_")) {
-          appStateDelta[key.substring(4)] = value;
-        } else if (key.startsWith("user_")) {
-          userStateDelta[key.substring(5)] = value;
-        } else if (!key.startsWith("temp_")) {
-          sessionStateDelta[key] = value;
-        }
-      }
+  getReasoningEngineId(appName) {
+    if (this.agentEngineId) {
+      return this.agentEngineId;
     }
-    return { appStateDelta, userStateDelta, sessionStateDelta };
-  }
-  /**
-   * Merge states for response (similar to Python implementation)
-   */
-  mergeState(appState, userState, sessionState) {
-    const mergedState = { ...sessionState };
-    for (const [key, value] of Object.entries(appState)) {
-      mergedState[`app_${key}`] = value;
+    if (/^\d+$/.test(appName)) {
+      return appName;
     }
-    for (const [key, value] of Object.entries(userState)) {
-      mergedState[`user_${key}`] = value;
+    const pattern = /^projects\/([a-zA-Z0-9-_]+)\/locations\/([a-zA-Z0-9-_]+)\/reasoningEngines\/(\d+)$/;
+    const match = appName.match(pattern);
+    if (!match) {
+      throw new Error(
+        `App name ${appName} is not valid. It should either be the full ReasoningEngine resource name, or the reasoning engine id.`
+      );
     }
-    return mergedState;
+    return match[3];
   }
-  /**
-   * Convert Event to storage event format
-   */
-  eventToStorageEvent(session, event) {
-    return {
-      id: event.id,
-      app_name: session.appName,
-      user_id: session.userId,
-      session_id: session.id,
-      invocation_id: event.invocationId || "",
-      author: event.author || "",
-      branch: event.branch || null,
-      content: event.content ? JSON.stringify(event.content) : null,
-      actions: event.actions ? JSON.stringify(event.actions) : null,
-      long_running_tool_ids_json: event.longRunningToolIds ? JSON.stringify(Array.from(event.longRunningToolIds)) : null,
-      grounding_metadata: event.groundingMetadata ? JSON.stringify(event.groundingMetadata) : null,
-      partial: event.partial || null,
-      turn_complete: event.turnComplete || null,
-      error_code: event.errorCode || null,
-      error_message: event.errorMessage || null,
-      interrupted: event.interrupted || null
-    };
+  getApiClient() {
+    const { GoogleGenAI: GoogleGenAI2 } = __require("@google/genai");
+    const client = new GoogleGenAI2({
+      vertexai: true,
+      project: this.project,
+      location: this.location
+    });
+    return client._api_client;
   }
-  /**
-   * Convert storage event to Event format - Fixed to match Event interface
-   */
-  storageEventToEvent(storageEvent) {
-    const baseEvent = {
-      id: storageEvent.id,
-      invocationId: storageEvent.invocation_id,
-      author: storageEvent.author,
-      branch: storageEvent.branch || void 0,
-      timestamp: this.timestampToUnixSeconds(storageEvent.timestamp),
-      content: storageEvent.content ? this.parseJsonSafely(storageEvent.content, null) : void 0,
-      actions: storageEvent.actions ? this.parseJsonSafely(storageEvent.actions, null) : void 0,
-      longRunningToolIds: storageEvent.long_running_tool_ids_json ? new Set(
-        this.parseJsonSafely(storageEvent.long_running_tool_ids_json, [])
-      ) : void 0,
-      groundingMetadata: storageEvent.grounding_metadata ? this.parseJsonSafely(storageEvent.grounding_metadata, null) : void 0,
-      partial: storageEvent.partial || void 0,
-      turnComplete: storageEvent.turn_complete || void 0,
-      errorCode: storageEvent.error_code || void 0,
-      errorMessage: storageEvent.error_message || void 0,
-      interrupted: storageEvent.interrupted || void 0
+  convertEventToJson(event) {
+    const metadataJson = {
+      partial: event.partial,
+      turn_complete: event.turnComplete,
+      interrupted: event.interrupted,
+      branch: event.branch,
+      long_running_tool_ids: event.longRunningToolIds ? Array.from(event.longRunningToolIds) : null
     };
-    return {
-      ...baseEvent,
-      // Add any missing required methods from the Event interface
-      isFinalResponse: () => baseEvent.turnComplete === true,
-      getFunctionCalls: () => {
-        if (baseEvent.actions && typeof baseEvent.actions === "object" && "functionCalls" in baseEvent.actions) {
-          return baseEvent.actions.functionCalls || [];
-        }
-        return [];
-      },
-      getFunctionResponses: () => {
-        if (baseEvent.actions && typeof baseEvent.actions === "object" && "functionResponses" in baseEvent.actions) {
-          return baseEvent.actions.functionResponses || [];
-        }
-        return [];
+    if (event.groundingMetadata) {
+      metadataJson.grounding_metadata = event.groundingMetadata;
+    }
+    const eventJson = {
+      author: event.author,
+      invocation_id: event.invocationId,
+      timestamp: {
+        seconds: Math.floor(event.timestamp),
+        nanos: Math.floor(
+          (event.timestamp - Math.floor(event.timestamp)) * 1e9
+        )
       },
-      hasTrailingCodeExecutionResult: () => {
-        if (baseEvent.actions && typeof baseEvent.actions === "object" && "hasTrailingCodeExecutionResult" in baseEvent.actions) {
-          return baseEvent.actions.hasTrailingCodeExecutionResult || false;
-        }
-        return false;
-      }
+      error_code: event.errorCode,
+      error_message: event.errorMessage,
+      event_metadata: metadataJson
     };
-  }
-  /**
-   * Updates the session state based on the event.
-   * Overrides the base class method to work with plain object state.
-   */
-  updateSessionState(session, event) {
-    if (!event.actions?.stateDelta) {
-      return;
+    if (event.actions) {
+      const actionsJson = {
+        skip_summarization: event.actions.skipSummarization,
+        state_delta: event.actions.stateDelta,
+        artifact_delta: event.actions.artifactDelta,
+        transfer_agent: event.actions.transferToAgent,
+        escalate: event.actions.escalate,
+        requested_auth_configs: event.actions.requestedAuthConfigs
+      };
+      eventJson.actions = actionsJson;
     }
-    for (const [key, value] of Object.entries(event.actions.stateDelta)) {
-      if (!key.startsWith("temp_")) {
-        session.state[key] = value;
-      }
+    if (event.content) {
+      eventJson.content = event.content;
     }
+    return eventJson;
   }
-};
-
-// src/sessions/database-factories.ts
-import dedent3 from "dedent";
-import { Kysely, MysqlDialect, PostgresDialect, SqliteDialect } from "kysely";
-function createDependencyError(packageName, dbType) {
-  return new Error(
-    dedent3`
-		Missing required peer dependency: ${packageName}
-		To use ${dbType} sessions, install the required package:
-			npm install ${packageName}
-			# or
-			pnpm add ${packageName}
-			# or
-			yarn add ${packageName}`
-  );
-}
-function createPostgresSessionService(connectionString, options) {
-  let Pool;
-  try {
-    ({ Pool } = __require("pg"));
-  } catch (error) {
-    throw createDependencyError("pg", "PostgreSQL");
-  }
-  const db = new Kysely({
-    dialect: new PostgresDialect({
-      pool: new Pool({
-        connectionString,
-        ...options
-      })
-    })
-  });
-  return new DatabaseSessionService({ db });
-}
-function createMysqlSessionService(connectionString, options) {
-  let createPool;
-  try {
-    ({ createPool } = __require("mysql2"));
-  } catch (error) {
-    throw createDependencyError("mysql2", "MySQL");
+  fromApiEvent(apiEvent) {
+    let eventActions = new EventActions();
+    if (apiEvent.actions) {
+      eventActions = new EventActions({
+        skipSummarization: apiEvent.actions.skipSummarization,
+        stateDelta: apiEvent.actions.stateDelta || {},
+        artifactDelta: apiEvent.actions.artifactDelta || {},
+        transferToAgent: apiEvent.actions.transferAgent,
+        escalate: apiEvent.actions.escalate,
+        requestedAuthConfigs: apiEvent.actions.requestedAuthConfigs || {}
+      });
+    }
+    const event = new Event({
+      id: apiEvent.name.split("/").pop(),
+      invocationId: apiEvent.invocationId,
+      author: apiEvent.author,
+      actions: eventActions,
+      content: this.decodeContent(apiEvent.content),
+      timestamp: new Date(apiEvent.timestamp).getTime() / 1e3
+    });
+    if (apiEvent.errorCode) {
+      event.errorCode = apiEvent.errorCode;
+    }
+    if (apiEvent.errorMessage) {
+      event.errorMessage = apiEvent.errorMessage;
+    }
+    if (apiEvent.eventMetadata) {
+      const longRunningToolIdsList = apiEvent.eventMetadata.longRunningToolIds;
+      event.partial = apiEvent.eventMetadata.partial;
+      event.turnComplete = apiEvent.eventMetadata.turnComplete;
+      event.interrupted = apiEvent.eventMetadata.interrupted;
+      event.branch = apiEvent.eventMetadata.branch;
+      event.groundingMetadata = this.decodeGroundingMetadata(
+        apiEvent.eventMetadata.groundingMetadata
+      );
+      event.longRunningToolIds = longRunningToolIdsList ? new Set(longRunningToolIdsList) : void 0;
+    }
+    return event;
   }
-  const db = new Kysely({
-    dialect: new MysqlDialect({
-      pool: createPool({
-        uri: connectionString,
-        ...options
-      })
-    })
-  });
-  return new DatabaseSessionService({ db });
-}
-function createSqliteSessionService(filename, options) {
-  let Database;
-  try {
-    Database = __require("better-sqlite3");
-  } catch (error) {
-    throw createDependencyError("better-sqlite3", "SQLite");
+  decodeContent(content) {
+    if (!content) return void 0;
+    return content;
   }
-  const db = new Kysely({
-    dialect: new SqliteDialect({
-      database: new Database(filename, options)
-    })
-  });
-  return new DatabaseSessionService({ db });
-}
-function createDatabaseSessionService(databaseUrl, options) {
-  if (databaseUrl.startsWith("postgres://") || databaseUrl.startsWith("postgresql://")) {
-    return createPostgresSessionService(databaseUrl, options);
+  decodeGroundingMetadata(groundingMetadata) {
+    if (!groundingMetadata) return void 0;
+    return groundingMetadata;
   }
-  if (databaseUrl.startsWith("mysql://")) {
-    return createMysqlSessionService(databaseUrl, options);
+};
+
+// src/sessions/database-session-service.ts
+import { sql } from "kysely";
+var DatabaseSessionService = class extends BaseSessionService {
+  db;
+  initialized = false;
+  constructor(config) {
+    super();
+    this.db = config.db;
+    if (!config.skipTableCreation) {
+      this.initializeDatabase().catch((error) => {
+        console.error("Failed to initialize database:", error);
+      });
+    }
   }
-  if (databaseUrl.startsWith("sqlite://") || databaseUrl.includes(".db") || databaseUrl === ":memory:") {
-    const filename = databaseUrl.startsWith("sqlite://") ? databaseUrl.substring(9) : databaseUrl;
-    return createSqliteSessionService(filename, options);
+  /**
+   * Initialize the database by creating required tables if they don't exist
+   */
+  async initializeDatabase() {
+    if (this.initialized) {
+      return;
+    }
+    try {
+      await this.db.schema.createTable("sessions").ifNotExists().addColumn("id", "varchar(128)", (col) => col.notNull()).addColumn("app_name", "varchar(128)", (col) => col.notNull()).addColumn("user_id", "varchar(128)", (col) => col.notNull()).addColumn("state", "text", (col) => col.defaultTo("{}")).addColumn(
+        "create_time",
+        "timestamp",
+        (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
+      ).addColumn(
+        "update_time",
+        "timestamp",
+        (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
+      ).addPrimaryKeyConstraint("sessions_pk", ["app_name", "user_id", "id"]).execute();
+      await this.db.schema.createTable("events").ifNotExists().addColumn("id", "varchar(128)", (col) => col.notNull()).addColumn("app_name", "varchar(128)", (col) => col.notNull()).addColumn("user_id", "varchar(128)", (col) => col.notNull()).addColumn("session_id", "varchar(128)", (col) => col.notNull()).addColumn("invocation_id", "varchar(256)").addColumn("author", "varchar(256)").addColumn("branch", "varchar(256)").addColumn(
+        "timestamp",
+        "timestamp",
+        (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`)
+      ).addColumn("content", "text").addColumn("actions", "text").addColumn("long_running_tool_ids_json", "text").addColumn("grounding_metadata", "text").addColumn("partial", "boolean").addColumn("turn_complete", "boolean").addColumn("error_code", "varchar(256)").addColumn("error_message", "varchar(1024)").addColumn("interrupted", "boolean").addPrimaryKeyConstraint("events_pk", [
+        "id",
+        "app_name",
+        "user_id",
+        "session_id"
+      ]).addForeignKeyConstraint(
+        "events_session_fk",
+        ["app_name", "user_id", "session_id"],
+        "sessions",
+        ["app_name", "user_id", "id"]
+      ).execute();
+      await this.db.schema.createTable("app_states").ifNotExists().addColumn("app_name", "varchar(128)", (col) => col.primaryKey()).addColumn("state", "text", (col) => col.defaultTo("{}")).addColumn(
+        "update_time",
+        "timestamp",
+        (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
+      ).execute();
+      await this.db.schema.createTable("user_states").ifNotExists().addColumn("app_name", "varchar(128)", (col) => col.notNull()).addColumn("user_id", "varchar(128)", (col) => col.notNull()).addColumn("state", "text", (col) => col.defaultTo("{}")).addColumn(
+        "update_time",
+        "timestamp",
+        (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull()
+      ).addPrimaryKeyConstraint("user_states_pk", ["app_name", "user_id"]).execute();
+      await this.db.schema.createIndex("idx_sessions_user_id").ifNotExists().on("sessions").column("user_id").execute();
+      this.initialized = true;
+    } catch (error) {
+      console.error("Error initializing database:", error);
+      throw error;
+    }
   }
-  throw new Error(`Unsupported database URL: ${databaseUrl}`);
-}
-
-// src/artifacts/gcs-artifact-service.ts
-init_logger();
-import {
-  Storage
-} from "@google-cloud/storage";
-var logger9 = new Logger({ name: "GcsArtifactService" });
-var GcsArtifactService = class {
-  bucketName;
-  storageClient;
-  bucket;
-  constructor(bucketName, options) {
-    this.bucketName = bucketName;
-    this.storageClient = new Storage(options);
-    this.bucket = this.storageClient.bucket(this.bucketName);
+  /**
+   * Ensure database is initialized before any operation
+   */
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initializeDatabase();
+    }
   }
-  fileHasUserNamespace(filename) {
-    return filename.startsWith("user:");
+  generateSessionId() {
+    return `session-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
   }
-  getBlobName(appName, userId, sessionId, filename, version) {
-    if (this.fileHasUserNamespace(filename)) {
-      return `${appName}/${userId}/user/${filename}/${version}`;
+  /**
+   * Helper to safely parse JSON strings
+   */
+  parseJsonSafely(jsonString, defaultValue) {
+    if (!jsonString) return defaultValue;
+    try {
+      return JSON.parse(jsonString);
+    } catch {
+      return defaultValue;
     }
-    return `${appName}/${userId}/${sessionId}/${filename}/${version}`;
   }
-  async saveArtifact(args) {
-    const { appName, userId, sessionId, filename, artifact } = args;
-    const versions = await this.listVersions({
-      appName,
-      userId,
-      sessionId,
-      filename
-    });
-    const version = versions.length === 0 ? 0 : Math.max(...versions) + 1;
-    const blobName = this.getBlobName(
-      appName,
-      userId,
-      sessionId,
-      filename,
-      version
-    );
-    const blob = this.bucket.file(blobName);
-    await blob.save(artifact.inlineData.data, {
-      contentType: artifact.inlineData.mimeType,
-      preconditionOpts: { ifGenerationMatch: 0 }
-    });
-    return version;
+  /**
+   * Convert database timestamp to Unix seconds
+   * Handles different timestamp formats from different databases
+   */
+  timestampToUnixSeconds(timestamp) {
+    if (timestamp instanceof Date) {
+      return timestamp.getTime() / 1e3;
+    }
+    if (typeof timestamp === "string") {
+      return new Date(timestamp).getTime() / 1e3;
+    }
+    if (typeof timestamp === "number") {
+      return timestamp > 1e10 ? timestamp / 1e3 : timestamp;
+    }
+    return Date.now() / 1e3;
   }
-  async loadArtifact(args) {
-    let { version } = args;
-    const { appName, userId, sessionId, filename } = args;
-    if (version === void 0 || version === null) {
-      const versions = await this.listVersions({
-        appName,
-        userId,
-        sessionId,
-        filename
-      });
-      if (versions.length === 0) {
-        return null;
+  async createSession(appName, userId, state, sessionId) {
+    await this.ensureInitialized();
+    const id = sessionId?.trim() || this.generateSessionId();
+    return await this.db.transaction().execute(async (trx) => {
+      const appState = await trx.selectFrom("app_states").selectAll().where("app_name", "=", appName).executeTakeFirst();
+      const userState = await trx.selectFrom("user_states").selectAll().where("app_name", "=", appName).where("user_id", "=", userId).executeTakeFirst();
+      let currentAppState = this.parseJsonSafely(appState?.state, {});
+      let currentUserState = this.parseJsonSafely(userState?.state, {});
+      if (!appState) {
+        await trx.insertInto("app_states").values({
+          app_name: appName,
+          state: "{}"
+        }).execute();
       }
-      version = Math.max(...versions);
-    }
-    const blobName = this.getBlobName(
-      appName,
-      userId,
-      sessionId,
-      filename,
-      version
-    );
-    const blob = this.bucket.file(blobName);
-    try {
-      const [metadata] = await blob.getMetadata();
-      const [artifactBuffer] = await blob.download();
-      if (!artifactBuffer) {
-        return null;
+      if (!userState) {
+        await trx.insertInto("user_states").values({
+          app_name: appName,
+          user_id: userId,
+          state: "{}"
+        }).execute();
       }
-      const part = {
-        inlineData: {
-          data: artifactBuffer.toString(),
-          mimeType: metadata.contentType || "application/octet-stream"
-        }
-      };
-      return part;
-    } catch (error) {
-      if (error?.code === 404) {
-        return null;
+      const { appStateDelta, userStateDelta, sessionStateDelta } = this.extractStateDelta(state);
+      currentAppState = { ...currentAppState, ...appStateDelta };
+      currentUserState = { ...currentUserState, ...userStateDelta };
+      if (Object.keys(appStateDelta).length > 0) {
+        await trx.updateTable("app_states").set({
+          state: JSON.stringify(currentAppState),
+          update_time: sql`CURRENT_TIMESTAMP`
+        }).where("app_name", "=", appName).execute();
       }
-      throw error;
-    }
-  }
-  async listArtifactKeys(args) {
-    const { appName, userId, sessionId } = args;
-    const filenames = /* @__PURE__ */ new Set();
-    const processBlobs = (blobNames) => {
-      for (const name of blobNames) {
-        const parts = name.split("/");
-        if (parts.length === 5) {
-          const filename = parts[3];
-          filenames.add(filename);
-        }
+      if (Object.keys(userStateDelta).length > 0) {
+        await trx.updateTable("user_states").set({
+          state: JSON.stringify(currentUserState),
+          update_time: sql`CURRENT_TIMESTAMP`
+        }).where("app_name", "=", appName).where("user_id", "=", userId).execute();
       }
-    };
-    const sessionPrefix = `${appName}/${userId}/${sessionId}/`;
-    const [sessionBlobs] = await this.storageClient.bucket(this.bucketName).getFiles({ prefix: sessionPrefix });
-    processBlobs(sessionBlobs.map((b) => b.name));
-    const userNamespacePrefix = `${appName}/${userId}/user/`;
-    const [userNamespaceBlobs] = await this.storageClient.bucket(this.bucketName).getFiles({ prefix: userNamespacePrefix });
-    processBlobs(userNamespaceBlobs.map((b) => b.name));
-    return Array.from(filenames).sort();
-  }
-  async deleteArtifact(args) {
-    const { appName, userId, sessionId, filename } = args;
-    const versions = await this.listVersions({
-      appName,
-      userId,
-      sessionId,
-      filename
-    });
-    const deletePromises = versions.map((version) => {
-      const blobName = this.getBlobName(
-        appName,
-        userId,
-        sessionId,
-        filename,
-        version
+      const result = await trx.insertInto("sessions").values({
+        id,
+        app_name: appName,
+        user_id: userId,
+        state: JSON.stringify(sessionStateDelta)
+      }).returningAll().executeTakeFirstOrThrow();
+      const mergedState = this.mergeState(
+        currentAppState,
+        currentUserState,
+        sessionStateDelta
       );
-      return this.bucket.file(blobName).delete();
+      return {
+        id: result.id,
+        appName: result.app_name,
+        userId: result.user_id,
+        state: mergedState,
+        events: [],
+        // Fixed type annotation
+        lastUpdateTime: this.timestampToUnixSeconds(result.update_time)
+      };
     });
-    await Promise.all(deletePromises);
   }
-  async listVersions(args) {
-    const { appName, userId, sessionId, filename } = args;
-    const prefix = this.getBlobName(appName, userId, sessionId, filename, "");
-    const [blobs] = await this.bucket.getFiles({ prefix });
-    const versions = [];
-    for (const blob of blobs) {
-      const parts = blob.name.split("/");
-      if (parts.length === 5) {
-        const versionStr = parts[4];
-        const versionNum = Number.parseInt(versionStr, 10);
-        if (!Number.isNaN(versionNum)) {
-          versions.push(versionNum);
-        }
+  async getSession(appName, userId, sessionId, config) {
+    await this.ensureInitialized();
+    return await this.db.transaction().execute(async (trx) => {
+      const storageSession = await trx.selectFrom("sessions").selectAll().where("app_name", "=", appName).where("user_id", "=", userId).where("id", "=", sessionId).executeTakeFirst();
+      if (!storageSession) {
+        return void 0;
       }
-    }
-    return versions.sort((a, b) => a - b);
+      let eventQuery = trx.selectFrom("events").selectAll().where("session_id", "=", sessionId).orderBy("timestamp", "desc");
+      if (config?.afterTimestamp) {
+        eventQuery = eventQuery.where(
+          "timestamp",
+          ">=",
+          new Date(config.afterTimestamp * 1e3)
+        );
+      }
+      if (config?.numRecentEvents) {
+        eventQuery = eventQuery.limit(config.numRecentEvents);
+      }
+      const storageEvents = await eventQuery.execute();
+      const appState = await trx.selectFrom("app_states").selectAll().where("app_name", "=", appName).executeTakeFirst();
+      const userState = await trx.selectFrom("user_states").selectAll().where("app_name", "=", appName).where("user_id", "=", userId).executeTakeFirst();
+      const currentAppState = this.parseJsonSafely(appState?.state, {});
+      const currentUserState = this.parseJsonSafely(userState?.state, {});
+      const sessionState = this.parseJsonSafely(storageSession.state, {});
+      const mergedState = this.mergeState(
+        currentAppState,
+        currentUserState,
+        sessionState
+      );
+      const events = storageEvents.reverse().map((storageEvent) => this.storageEventToEvent(storageEvent));
+      return {
+        id: sessionId,
+        appName,
+        userId,
+        state: mergedState,
+        events,
+        // Now properly typed as Event[]
+        lastUpdateTime: this.timestampToUnixSeconds(storageSession.update_time)
+      };
+    });
   }
-};
-
-// src/artifacts/in-memory-artifact-service.ts
-init_logger();
-var logger10 = new Logger({ name: "InMemoryArtifactService" });
-var InMemoryArtifactService = class {
-  artifacts = /* @__PURE__ */ new Map();
-  fileHasUserNamespace(filename) {
-    return filename.startsWith("user:");
+  async updateSession(session) {
+    await this.ensureInitialized();
+    await this.db.updateTable("sessions").set({
+      state: JSON.stringify(session.state),
+      update_time: sql`CURRENT_TIMESTAMP`
+    }).where("app_name", "=", session.appName).where("user_id", "=", session.userId).where("id", "=", session.id).execute();
   }
-  getArtifactPath(appName, userId, sessionId, filename) {
-    if (this.fileHasUserNamespace(filename)) {
-      return `${appName}/${userId}/user/${filename}`;
-    }
-    return `${appName}/${userId}/${sessionId}/${filename}`;
+  async listSessions(appName, userId) {
+    await this.ensureInitialized();
+    const results = await this.db.selectFrom("sessions").selectAll().where("app_name", "=", appName).where("user_id", "=", userId).execute();
+    const sessions = results.map((storageSession) => ({
+      id: storageSession.id,
+      appName: storageSession.app_name,
+      userId: storageSession.user_id,
+      state: {},
+      events: [],
+      // Fixed type annotation
+      lastUpdateTime: this.timestampToUnixSeconds(storageSession.update_time)
+    }));
+    return { sessions };
   }
-  async saveArtifact(args) {
-    const { appName, userId, sessionId, filename, artifact } = args;
-    const path2 = this.getArtifactPath(appName, userId, sessionId, filename);
-    if (!this.artifacts.has(path2)) {
-      this.artifacts.set(path2, []);
-    }
-    const versions = this.artifacts.get(path2);
-    const version = versions.length;
-    versions.push(artifact);
-    return version;
+  async deleteSession(appName, userId, sessionId) {
+    await this.ensureInitialized();
+    await this.db.deleteFrom("sessions").where("app_name", "=", appName).where("user_id", "=", userId).where("id", "=", sessionId).execute();
   }
-  async loadArtifact(args) {
-    const { appName, userId, sessionId, filename, version } = args;
-    const path2 = this.getArtifactPath(appName, userId, sessionId, filename);
-    const versions = this.artifacts.get(path2);
-    if (!versions || versions.length === 0) {
-      return null;
-    }
-    let targetVersion = version;
-    if (targetVersion === void 0 || targetVersion === null) {
-      targetVersion = versions.length - 1;
-    }
-    if (targetVersion < 0) {
-      targetVersion = versions.length + targetVersion;
-    }
-    if (targetVersion < 0 || targetVersion >= versions.length) {
-      return null;
+  async appendEvent(session, event) {
+    await this.ensureInitialized();
+    if (event.partial) {
+      return event;
     }
-    return versions[targetVersion];
-  }
-  async listArtifactKeys(args) {
-    const { appName, userId, sessionId } = args;
-    const sessionPrefix = `${appName}/${userId}/${sessionId}/`;
-    const userNamespacePrefix = `${appName}/${userId}/user/`;
-    const filenames = [];
-    for (const path2 of this.artifacts.keys()) {
-      if (path2.startsWith(sessionPrefix)) {
-        const filename = path2.substring(sessionPrefix.length);
-        filenames.push(filename);
-      } else if (path2.startsWith(userNamespacePrefix)) {
-        const filename = path2.substring(userNamespacePrefix.length);
-        filenames.push(filename);
+    return await this.db.transaction().execute(async (trx) => {
+      const storageSession = await trx.selectFrom("sessions").selectAll().where("app_name", "=", session.appName).where("user_id", "=", session.userId).where("id", "=", session.id).executeTakeFirstOrThrow();
+      if (this.timestampToUnixSeconds(storageSession.update_time) > session.lastUpdateTime) {
+        throw new Error(
+          `The last_update_time provided in the session object ${new Date(session.lastUpdateTime * 1e3).toISOString()} is earlier than the update_time in the storage_session ${storageSession.update_time.toISOString()}. Please check if it is a stale session.`
+        );
       }
-    }
-    return filenames.sort();
-  }
-  async deleteArtifact(args) {
-    const { appName, userId, sessionId, filename } = args;
-    const path2 = this.getArtifactPath(appName, userId, sessionId, filename);
-    if (!this.artifacts.has(path2)) {
-      return;
-    }
-    this.artifacts.delete(path2);
-  }
-  async listVersions(args) {
-    const { appName, userId, sessionId, filename } = args;
-    const path2 = this.getArtifactPath(appName, userId, sessionId, filename);
-    const versions = this.artifacts.get(path2);
-    if (!versions || versions.length === 0) {
-      return [];
-    }
-    return Array.from({ length: versions.length }, (_, i) => i);
-  }
-};
-
-// src/flows/index.ts
-var flows_exports = {};
-__export(flows_exports, {
-  AF_FUNCTION_CALL_ID_PREFIX: () => AF_FUNCTION_CALL_ID_PREFIX,
-  AutoFlow: () => AutoFlow,
-  BaseLlmFlow: () => BaseLlmFlow,
-  BaseLlmRequestProcessor: () => BaseLlmRequestProcessor,
-  BaseLlmResponseProcessor: () => BaseLlmResponseProcessor,
-  REQUEST_EUC_FUNCTION_CALL_NAME: () => REQUEST_EUC_FUNCTION_CALL_NAME,
-  SingleFlow: () => SingleFlow,
-  agentTransferRequestProcessor: () => requestProcessor8,
-  basicRequestProcessor: () => requestProcessor,
-  codeExecutionRequestProcessor: () => requestProcessor7,
-  codeExecutionResponseProcessor: () => responseProcessor2,
-  contentRequestProcessor: () => requestProcessor5,
-  generateAuthEvent: () => generateAuthEvent,
-  generateClientFunctionCallId: () => generateClientFunctionCallId,
-  getLongRunningFunctionCalls: () => getLongRunningFunctionCalls,
-  handleFunctionCallsAsync: () => handleFunctionCallsAsync,
-  handleFunctionCallsLive: () => handleFunctionCallsLive,
-  identityRequestProcessor: () => requestProcessor3,
-  instructionsRequestProcessor: () => requestProcessor4,
-  mergeParallelFunctionResponseEvents: () => mergeParallelFunctionResponseEvents,
-  nlPlanningRequestProcessor: () => requestProcessor6,
-  nlPlanningResponseProcessor: () => responseProcessor,
-  populateClientFunctionCallId: () => populateClientFunctionCallId,
-  removeClientFunctionCallId: () => removeClientFunctionCallId
-});
-
-// src/runners.ts
-import { SpanStatusCode } from "@opentelemetry/api";
-init_logger();
-var logger11 = new Logger({ name: "Runner" });
-function _findFunctionCallEventIfLastEventIsFunctionResponse(session) {
-  const events = session.events;
-  if (!events || events.length === 0) {
-    return null;
+      const appState = await trx.selectFrom("app_states").selectAll().where("app_name", "=", session.appName).executeTakeFirst();
+      const userState = await trx.selectFrom("user_states").selectAll().where("app_name", "=", session.appName).where("user_id", "=", session.userId).executeTakeFirst();
+      let currentAppState = this.parseJsonSafely(appState?.state, {});
+      let currentUserState = this.parseJsonSafely(userState?.state, {});
+      let sessionState = this.parseJsonSafely(storageSession.state, {});
+      let appStateDelta = {};
+      let userStateDelta = {};
+      let sessionStateDelta = {};
+      if (event.actions?.stateDelta) {
+        const deltas = this.extractStateDelta(event.actions.stateDelta);
+        appStateDelta = deltas.appStateDelta;
+        userStateDelta = deltas.userStateDelta;
+        sessionStateDelta = deltas.sessionStateDelta;
+      }
+      if (Object.keys(appStateDelta).length > 0) {
+        currentAppState = { ...currentAppState, ...appStateDelta };
+        await trx.updateTable("app_states").set({
+          state: JSON.stringify(currentAppState),
+          update_time: sql`CURRENT_TIMESTAMP`
+        }).where("app_name", "=", session.appName).execute();
+      }
+      if (Object.keys(userStateDelta).length > 0) {
+        currentUserState = { ...currentUserState, ...userStateDelta };
+        await trx.updateTable("user_states").set({
+          state: JSON.stringify(currentUserState),
+          update_time: sql`CURRENT_TIMESTAMP`
+        }).where("app_name", "=", session.appName).where("user_id", "=", session.userId).execute();
+      }
+      if (Object.keys(sessionStateDelta).length > 0) {
+        sessionState = { ...sessionState, ...sessionStateDelta };
+        await trx.updateTable("sessions").set({
+          state: JSON.stringify(sessionState),
+          update_time: sql`CURRENT_TIMESTAMP`
+        }).where("app_name", "=", session.appName).where("user_id", "=", session.userId).where("id", "=", session.id).execute();
+      }
+      await trx.insertInto("events").values({
+        ...this.eventToStorageEvent(session, event),
+        timestamp: sql`CURRENT_TIMESTAMP`
+      }).execute();
+      const updatedSession = await trx.selectFrom("sessions").select("update_time").where("app_name", "=", session.appName).where("user_id", "=", session.userId).where("id", "=", session.id).executeTakeFirstOrThrow();
+      session.lastUpdateTime = this.timestampToUnixSeconds(
+        updatedSession.update_time
+      );
+      super.appendEvent(session, event);
+      return event;
+    });
   }
-  const lastEvent = events[events.length - 1];
-  if (lastEvent.content?.parts?.some((part) => part.functionResponse)) {
-    const functionCallId = lastEvent.content.parts.find(
-      (part) => part.functionResponse
-    )?.functionResponse?.id;
-    if (!functionCallId) return null;
-    for (let i = events.length - 2; i >= 0; i--) {
-      const event = events[i];
-      const functionCalls = event.getFunctionCalls?.() || [];
-      for (const functionCall of functionCalls) {
-        if (functionCall.id === functionCallId) {
-          return event;
+  /**
+   * Extract state deltas based on prefixes (similar to Python implementation)
+   */
+  extractStateDelta(state) {
+    const appStateDelta = {};
+    const userStateDelta = {};
+    const sessionStateDelta = {};
+    if (state) {
+      for (const [key, value] of Object.entries(state)) {
+        if (key.startsWith("app_")) {
+          appStateDelta[key.substring(4)] = value;
+        } else if (key.startsWith("user_")) {
+          userStateDelta[key.substring(5)] = value;
+        } else if (!key.startsWith("temp_")) {
+          sessionStateDelta[key] = value;
         }
       }
     }
+    return { appStateDelta, userStateDelta, sessionStateDelta };
   }
-  return null;
-}
-var Runner = class {
-  /**
-   * The app name of the runner.
-   */
-  appName;
-  /**
-   * The root agent to run.
-   */
-  agent;
-  /**
-   * The artifact service for the runner.
-   */
-  artifactService;
-  /**
-   * The session service for the runner.
-   */
-  sessionService;
   /**
-   * The memory service for the runner.
+   * Merge states for response (similar to Python implementation)
    */
-  memoryService;
+  mergeState(appState, userState, sessionState) {
+    const mergedState = { ...sessionState };
+    for (const [key, value] of Object.entries(appState)) {
+      mergedState[`app_${key}`] = value;
+    }
+    for (const [key, value] of Object.entries(userState)) {
+      mergedState[`user_${key}`] = value;
+    }
+    return mergedState;
+  }
   /**
-   * Initializes the Runner.
+   * Convert Event to storage event format
    */
-  constructor({
-    appName,
-    agent,
-    artifactService,
-    sessionService,
-    memoryService
-  }) {
-    this.appName = appName;
-    this.agent = agent;
-    this.artifactService = artifactService;
-    this.sessionService = sessionService;
-    this.memoryService = memoryService;
+  eventToStorageEvent(session, event) {
+    return {
+      id: event.id,
+      app_name: session.appName,
+      user_id: session.userId,
+      session_id: session.id,
+      invocation_id: event.invocationId || "",
+      author: event.author || "",
+      branch: event.branch || null,
+      content: event.content ? JSON.stringify(event.content) : null,
+      actions: event.actions ? JSON.stringify(event.actions) : null,
+      long_running_tool_ids_json: event.longRunningToolIds ? JSON.stringify(Array.from(event.longRunningToolIds)) : null,
+      grounding_metadata: event.groundingMetadata ? JSON.stringify(event.groundingMetadata) : null,
+      partial: event.partial || null,
+      turn_complete: event.turnComplete || null,
+      error_code: event.errorCode || null,
+      error_message: event.errorMessage || null,
+      interrupted: event.interrupted || null
+    };
   }
   /**
-   * Runs the agent synchronously.
-   * NOTE: This sync interface is only for local testing and convenience purpose.
-   * Consider using `runAsync` for production usage.
+   * Convert storage event to Event format - Fixed to match Event interface
    */
-  run({
-    userId,
-    sessionId,
-    newMessage,
-    runConfig = new RunConfig()
-  }) {
-    const eventQueue = [];
-    let queueIndex = 0;
-    let asyncCompleted = false;
-    const invokeRunAsync = async () => {
-      try {
-        for await (const event of this.runAsync({
-          userId,
-          sessionId,
-          newMessage,
-          runConfig
-        })) {
-          eventQueue.push(event);
-        }
-      } finally {
-        eventQueue.push(null);
-        asyncCompleted = true;
-      }
+  storageEventToEvent(storageEvent) {
+    const baseEvent = {
+      id: storageEvent.id,
+      invocationId: storageEvent.invocation_id,
+      author: storageEvent.author,
+      branch: storageEvent.branch || void 0,
+      timestamp: this.timestampToUnixSeconds(storageEvent.timestamp),
+      content: storageEvent.content ? this.parseJsonSafely(storageEvent.content, null) : void 0,
+      actions: storageEvent.actions ? this.parseJsonSafely(storageEvent.actions, null) : void 0,
+      longRunningToolIds: storageEvent.long_running_tool_ids_json ? new Set(
+        this.parseJsonSafely(storageEvent.long_running_tool_ids_json, [])
+      ) : void 0,
+      groundingMetadata: storageEvent.grounding_metadata ? this.parseJsonSafely(storageEvent.grounding_metadata, null) : void 0,
+      partial: storageEvent.partial || void 0,
+      turnComplete: storageEvent.turn_complete || void 0,
+      errorCode: storageEvent.error_code || void 0,
+      errorMessage: storageEvent.error_message || void 0,
+      interrupted: storageEvent.interrupted || void 0
     };
-    invokeRunAsync();
-    return function* () {
-      while (true) {
-        while (queueIndex >= eventQueue.length && !asyncCompleted) {
+    return {
+      ...baseEvent,
+      // Add any missing required methods from the Event interface
+      isFinalResponse: () => baseEvent.turnComplete === true,
+      getFunctionCalls: () => {
+        if (baseEvent.actions && typeof baseEvent.actions === "object" && "functionCalls" in baseEvent.actions) {
+          return baseEvent.actions.functionCalls || [];
         }
-        if (queueIndex >= eventQueue.length && asyncCompleted) {
-          break;
+        return [];
+      },
+      getFunctionResponses: () => {
+        if (baseEvent.actions && typeof baseEvent.actions === "object" && "functionResponses" in baseEvent.actions) {
+          return baseEvent.actions.functionResponses || [];
         }
-        const event = eventQueue[queueIndex++];
-        if (event === null) {
-          break;
+        return [];
+      },
+      hasTrailingCodeExecutionResult: () => {
+        if (baseEvent.actions && typeof baseEvent.actions === "object" && "hasTrailingCodeExecutionResult" in baseEvent.actions) {
+          return baseEvent.actions.hasTrailingCodeExecutionResult || false;
         }
-        yield event;
+        return false;
       }
-    }();
+    };
   }
   /**
-   * Main entry method to run the agent in this runner.
+   * Updates the session state based on the event.
+   * Overrides the base class method to work with plain object state.
    */
-  async *runAsync({
-    userId,
-    sessionId,
-    newMessage,
-    runConfig = new RunConfig()
-  }) {
-    const span = tracer.startSpan("invocation");
-    try {
-      const session = await this.sessionService.getSession(
-        this.appName,
+  updateSessionState(session, event) {
+    if (!event.actions?.stateDelta) {
+      return;
+    }
+    for (const [key, value] of Object.entries(event.actions.stateDelta)) {
+      if (!key.startsWith("temp_")) {
+        session.state[key] = value;
+      }
+    }
+  }
+};
+
+// src/sessions/database-factories.ts
+import dedent3 from "dedent";
+import { Kysely, MysqlDialect, PostgresDialect, SqliteDialect } from "kysely";
+function createDependencyError(packageName, dbType) {
+  return new Error(
+    dedent3`
+		Missing required peer dependency: ${packageName}
+		To use ${dbType} sessions, install the required package:
+			npm install ${packageName}
+			# or
+			pnpm add ${packageName}
+			# or
+			yarn add ${packageName}`
+  );
+}
+function createPostgresSessionService(connectionString, options) {
+  let Pool;
+  try {
+    ({ Pool } = __require("pg"));
+  } catch (error) {
+    throw createDependencyError("pg", "PostgreSQL");
+  }
+  const db = new Kysely({
+    dialect: new PostgresDialect({
+      pool: new Pool({
+        connectionString,
+        ...options
+      })
+    })
+  });
+  return new DatabaseSessionService({ db });
+}
+function createMysqlSessionService(connectionString, options) {
+  let createPool;
+  try {
+    ({ createPool } = __require("mysql2"));
+  } catch (error) {
+    throw createDependencyError("mysql2", "MySQL");
+  }
+  const db = new Kysely({
+    dialect: new MysqlDialect({
+      pool: createPool({
+        uri: connectionString,
+        ...options
+      })
+    })
+  });
+  return new DatabaseSessionService({ db });
+}
+function createSqliteSessionService(filename, options) {
+  let Database;
+  try {
+    Database = __require("better-sqlite3");
+  } catch (error) {
+    throw createDependencyError("better-sqlite3", "SQLite");
+  }
+  const db = new Kysely({
+    dialect: new SqliteDialect({
+      database: new Database(filename, options)
+    })
+  });
+  return new DatabaseSessionService({ db });
+}
+function createDatabaseSessionService(databaseUrl, options) {
+  if (databaseUrl.startsWith("postgres://") || databaseUrl.startsWith("postgresql://")) {
+    return createPostgresSessionService(databaseUrl, options);
+  }
+  if (databaseUrl.startsWith("mysql://")) {
+    return createMysqlSessionService(databaseUrl, options);
+  }
+  if (databaseUrl.startsWith("sqlite://") || databaseUrl.includes(".db") || databaseUrl === ":memory:") {
+    const filename = databaseUrl.startsWith("sqlite://") ? databaseUrl.substring(9) : databaseUrl;
+    return createSqliteSessionService(filename, options);
+  }
+  throw new Error(`Unsupported database URL: ${databaseUrl}`);
+}
+
+// src/artifacts/gcs-artifact-service.ts
+init_logger();
+import {
+  Storage
+} from "@google-cloud/storage";
+var logger11 = new Logger({ name: "GcsArtifactService" });
+var GcsArtifactService = class {
+  bucketName;
+  storageClient;
+  bucket;
+  constructor(bucketName, options) {
+    this.bucketName = bucketName;
+    this.storageClient = new Storage(options);
+    this.bucket = this.storageClient.bucket(this.bucketName);
+  }
+  fileHasUserNamespace(filename) {
+    return filename.startsWith("user:");
+  }
+  getBlobName(appName, userId, sessionId, filename, version) {
+    if (this.fileHasUserNamespace(filename)) {
+      return `${appName}/${userId}/user/${filename}/${version}`;
+    }
+    return `${appName}/${userId}/${sessionId}/${filename}/${version}`;
+  }
+  async saveArtifact(args) {
+    const { appName, userId, sessionId, filename, artifact } = args;
+    const versions = await this.listVersions({
+      appName,
+      userId,
+      sessionId,
+      filename
+    });
+    const version = versions.length === 0 ? 0 : Math.max(...versions) + 1;
+    const blobName = this.getBlobName(
+      appName,
+      userId,
+      sessionId,
+      filename,
+      version
+    );
+    const blob = this.bucket.file(blobName);
+    await blob.save(artifact.inlineData.data, {
+      contentType: artifact.inlineData.mimeType,
+      preconditionOpts: { ifGenerationMatch: 0 }
+    });
+    return version;
+  }
+  async loadArtifact(args) {
+    let { version } = args;
+    const { appName, userId, sessionId, filename } = args;
+    if (version === void 0 || version === null) {
+      const versions = await this.listVersions({
+        appName,
         userId,
-        sessionId
-      );
-      if (!session) {
-        throw new Error(`Session not found: ${sessionId}`);
-      }
-      const invocationContext = this._newInvocationContext(session, {
-        newMessage,
-        runConfig
+        sessionId,
+        filename
       });
-      if (newMessage) {
-        await this._appendNewMessageToSession(
-          session,
-          newMessage,
-          invocationContext,
-          runConfig.saveInputBlobsAsArtifacts || false
-        );
+      if (versions.length === 0) {
+        return null;
       }
-      invocationContext.agent = this._findAgentToRun(session, this.agent);
-      for await (const event of invocationContext.agent.runAsync(
-        invocationContext
-      )) {
-        if (!event.partial) {
-          await this.sessionService.appendEvent(session, event);
-        }
-        yield event;
+      version = Math.max(...versions);
+    }
+    const blobName = this.getBlobName(
+      appName,
+      userId,
+      sessionId,
+      filename,
+      version
+    );
+    const blob = this.bucket.file(blobName);
+    try {
+      const [metadata] = await blob.getMetadata();
+      const [artifactBuffer] = await blob.download();
+      if (!artifactBuffer) {
+        return null;
       }
+      const part = {
+        inlineData: {
+          data: artifactBuffer.toString(),
+          mimeType: metadata.contentType || "application/octet-stream"
+        }
+      };
+      return part;
     } catch (error) {
-      logger11.debug("Error running agent:", error);
-      span.recordException(error);
-      span.setStatus({
-        code: SpanStatusCode.ERROR,
-        message: error instanceof Error ? error.message : "Unknown error"
-      });
+      if (error?.code === 404) {
+        return null;
+      }
       throw error;
-    } finally {
-      span.end();
     }
   }
-  /**
-   * Appends a new message to the session.
-   */
-  async _appendNewMessageToSession(session, newMessage, invocationContext, saveInputBlobsAsArtifacts = false) {
-    if (!newMessage.parts) {
-      throw new Error("No parts in the new_message.");
-    }
-    if (this.artifactService && saveInputBlobsAsArtifacts) {
-      for (let i = 0; i < newMessage.parts.length; i++) {
-        const part = newMessage.parts[i];
-        if (!part.inlineData) {
-          continue;
+  async listArtifactKeys(args) {
+    const { appName, userId, sessionId } = args;
+    const filenames = /* @__PURE__ */ new Set();
+    const processBlobs = (blobNames) => {
+      for (const name of blobNames) {
+        const parts = name.split("/");
+        if (parts.length === 5) {
+          const filename = parts[3];
+          filenames.add(filename);
         }
-        const fileName = `artifact_${invocationContext.invocationId}_${i}`;
-        await this.artifactService.saveArtifact({
-          appName: this.appName,
-          userId: session.userId,
-          sessionId: session.id,
-          filename: fileName,
-          artifact: part
-        });
-        newMessage.parts[i] = {
-          text: `Uploaded file: ${fileName}. It is saved into artifacts`
-        };
       }
-    }
-    const userContent = {
-      ...newMessage,
-      role: "user"
-      // Ensure role is set for content filtering
     };
-    const event = new Event({
-      invocationId: invocationContext.invocationId,
-      author: "user",
-      content: userContent
-    });
-    await this.sessionService.appendEvent(session, event);
+    const sessionPrefix = `${appName}/${userId}/${sessionId}/`;
+    const [sessionBlobs] = await this.storageClient.bucket(this.bucketName).getFiles({ prefix: sessionPrefix });
+    processBlobs(sessionBlobs.map((b) => b.name));
+    const userNamespacePrefix = `${appName}/${userId}/user/`;
+    const [userNamespaceBlobs] = await this.storageClient.bucket(this.bucketName).getFiles({ prefix: userNamespacePrefix });
+    processBlobs(userNamespaceBlobs.map((b) => b.name));
+    return Array.from(filenames).sort();
   }
-  /**
-   * Finds the agent to run to continue the session.
-   */
-  _findAgentToRun(session, rootAgent) {
-    const event = _findFunctionCallEventIfLastEventIsFunctionResponse(session);
-    if (event?.author) {
-      return rootAgent.findAgent(event.author);
-    }
-    const nonUserEvents = session.events?.filter((e) => e.author !== "user").reverse() || [];
-    for (const event2 of nonUserEvents) {
-      if (event2.author === rootAgent.name) {
-        return rootAgent;
-      }
-      const agent = rootAgent.findSubAgent?.(event2.author);
-      if (!agent) {
-        logger11.debug(
-          `Event from an unknown agent: ${event2.author}, event id: ${event2.id}`
-        );
-        continue;
-      }
-      if (this._isTransferableAcrossAgentTree(agent)) {
-        return agent;
-      }
-    }
-    return rootAgent;
+  async deleteArtifact(args) {
+    const { appName, userId, sessionId, filename } = args;
+    const versions = await this.listVersions({
+      appName,
+      userId,
+      sessionId,
+      filename
+    });
+    const deletePromises = versions.map((version) => {
+      const blobName = this.getBlobName(
+        appName,
+        userId,
+        sessionId,
+        filename,
+        version
+      );
+      return this.bucket.file(blobName).delete();
+    });
+    await Promise.all(deletePromises);
   }
-  /**
-   * Whether the agent to run can transfer to any other agent in the agent tree.
-   */
-  _isTransferableAcrossAgentTree(agentToRun) {
-    let agent = agentToRun;
-    while (agent) {
-      if (!(agent instanceof LlmAgent)) {
-        return false;
-      }
-      if (agent.disallowTransferToParent) {
-        return false;
+  async listVersions(args) {
+    const { appName, userId, sessionId, filename } = args;
+    const prefix = this.getBlobName(appName, userId, sessionId, filename, "");
+    const [blobs] = await this.bucket.getFiles({ prefix });
+    const versions = [];
+    for (const blob of blobs) {
+      const parts = blob.name.split("/");
+      if (parts.length === 5) {
+        const versionStr = parts[4];
+        const versionNum = Number.parseInt(versionStr, 10);
+        if (!Number.isNaN(versionNum)) {
+          versions.push(versionNum);
+        }
       }
-      agent = agent.parentAgent || null;
     }
-    return true;
-  }
-  /**
-   * Creates a new invocation context.
-   */
-  _newInvocationContext(session, {
-    newMessage,
-    runConfig = new RunConfig()
-  }) {
-    const invocationId = newInvocationContextId();
-    return new InvocationContext({
-      artifactService: this.artifactService,
-      sessionService: this.sessionService,
-      memoryService: this.memoryService,
-      invocationId,
-      agent: this.agent,
-      session,
-      userContent: newMessage || null,
-      liveRequestQueue: null,
-      runConfig
-    });
-  }
-};
-var InMemoryRunner = class extends Runner {
-  /**
-   * Deprecated. Please don't use. The in-memory session service for the runner.
-   */
-  _inMemorySessionService;
-  /**
-   * Initializes the InMemoryRunner.
-   */
-  constructor(agent, { appName = "InMemoryRunner" } = {}) {
-    const inMemorySessionService = new InMemorySessionService();
-    super({
-      appName,
-      agent,
-      artifactService: new InMemoryArtifactService(),
-      sessionService: inMemorySessionService,
-      memoryService: new InMemoryMemoryService()
-    });
-    this._inMemorySessionService = inMemorySessionService;
+    return versions.sort((a, b) => a - b);
   }
 };
 
+// src/flows/index.ts
+var flows_exports = {};
+__export(flows_exports, {
+  AF_FUNCTION_CALL_ID_PREFIX: () => AF_FUNCTION_CALL_ID_PREFIX,
+  AutoFlow: () => AutoFlow,
+  BaseLlmFlow: () => BaseLlmFlow,
+  BaseLlmRequestProcessor: () => BaseLlmRequestProcessor,
+  BaseLlmResponseProcessor: () => BaseLlmResponseProcessor,
+  REQUEST_EUC_FUNCTION_CALL_NAME: () => REQUEST_EUC_FUNCTION_CALL_NAME,
+  SingleFlow: () => SingleFlow,
+  agentTransferRequestProcessor: () => requestProcessor8,
+  basicRequestProcessor: () => requestProcessor,
+  codeExecutionRequestProcessor: () => requestProcessor7,
+  codeExecutionResponseProcessor: () => responseProcessor2,
+  contentRequestProcessor: () => requestProcessor5,
+  generateAuthEvent: () => generateAuthEvent,
+  generateClientFunctionCallId: () => generateClientFunctionCallId,
+  getLongRunningFunctionCalls: () => getLongRunningFunctionCalls,
+  handleFunctionCallsAsync: () => handleFunctionCallsAsync,
+  handleFunctionCallsLive: () => handleFunctionCallsLive,
+  identityRequestProcessor: () => requestProcessor3,
+  instructionsRequestProcessor: () => requestProcessor4,
+  mergeParallelFunctionResponseEvents: () => mergeParallelFunctionResponseEvents,
+  nlPlanningRequestProcessor: () => requestProcessor6,
+  nlPlanningResponseProcessor: () => responseProcessor,
+  populateClientFunctionCallId: () => populateClientFunctionCallId,
+  removeClientFunctionCallId: () => removeClientFunctionCallId
+});
+
 // src/version.ts
 var VERSION = "0.1.0";
 export {
   AF_FUNCTION_CALL_ID_PREFIX,
   LlmAgent as Agent,
+  AgentBuilder,
   agents_exports as Agents,
   AnthropicLlm,
   ApiKeyCredential,