@dexto/core 1.6.26 → 1.7.0

package/dist/agent/DextoAgent.js

@@ -6,6 +6,7 @@ import {
 var _DextoAgent_decorators, _init;
 import { randomUUID } from "crypto";
 import { setMaxListeners } from "events";
+import { ZodError } from "zod";
 import { SkillsContributor } from "../systemPrompt/contributors.js";
 import { expandMessageReferences } from "../resources/index.js";
 import { expandBlobReferences, fileTypesToMimePatterns } from "../context/utils.js";
@@ -13,7 +14,7 @@ import { StorageManager } from "../storage/index.js";
 import { PromptManager } from "../prompts/index.js";
 import { SessionError } from "../session/index.js";
 import { InstrumentClass } from "../telemetry/decorators.js";
-import { trace, context, propagation } from "@opentelemetry/api";
+import { trace, context } from "@opentelemetry/api";
 import { resolveAndValidateLLMConfig } from "../llm/resolver.js";
 import { validateInputForLLM } from "../llm/validation.js";
 import { LLMError } from "../llm/errors.js";
@@ -51,6 +52,7 @@ import {
 } from "../events/index.js";
 import { safeStringify } from "../utils/safe-stringify.js";
 import { deriveHeuristicTitle, generateSessionTitle } from "../session/title-generator.js";
+import { createAgentRunContext } from "../runtime/run-context.js";
 const requiredServices = [
   "mcpManager",
   "toolManager",
@@ -286,6 +288,9 @@ Either:
       };
       services.toolManager.setToolExecutionContextFactory((baseContext) => ({
         ...baseContext,
+        ...baseContext.runContext?.hostRuntime !== void 0 && {
+          hostRuntime: baseContext.runContext.hostRuntime
+        },
         agent: this,
         storage: toolExecutionStorage,
         services: toolExecutionServices
@@ -610,7 +615,8 @@ Either:
       ...responseEvent.estimatedCost !== void 0 && {
         estimatedCost: responseEvent.estimatedCost
       },
-      ...responseEvent.pricingStatus && { pricingStatus: responseEvent.pricingStatus }
+      ...responseEvent.pricingStatus && { pricingStatus: responseEvent.pricingStatus },
+      ...responseEvent.hostRuntime && { hostRuntime: responseEvent.hostRuntime }
     };
   }
   /**
@@ -648,8 +654,28 @@ Either:
     if (!sessionId) {
       throw AgentError.apiValidationError("sessionId is required");
     }
+    if (this.activeStreamControllers.has(sessionId)) {
+      throw AgentError.sessionBusy(sessionId);
+    }
     const signal = options?.signal;
     const disconnectSignal = options?.disconnectSignal ?? signal;
+    let runContext;
+    try {
+      runContext = createAgentRunContext({
+        sessionId,
+        hostRuntime: options?.executionContext,
+        parentContext: context.active()
+      });
+    } catch (error) {
+      if (error instanceof ZodError) {
+        throw AgentError.apiValidationError(
+          "executionContext is invalid",
+          zodToIssues(error)
+        );
+      }
+      throw error;
+    }
+    const executionContext = runContext.hostRuntime;
     let contentParts = typeof content === "string" ? [{ type: "text", text: content }] : [...content];
     const eventQueue = [];
     let completed = false;
@@ -659,23 +685,36 @@ Either:
     const cleanupSignal = controller.signal;
     this.activeStreamControllers.set(sessionId, controller);
     setMaxListeners(30, cleanupSignal);
-    const listeners = [];
+    const listenerCleanups = [];
     let detachDisconnectAbortListener;
+    const addStreamingListener = (event, listener) => {
+      this.agentEventBus.on(event, listener, { signal: cleanupSignal });
+      listenerCleanups.push(() => {
+        this.agentEventBus.off(event, listener);
+      });
+    };
     const cleanupListeners = () => {
       detachDisconnectAbortListener?.();
       detachDisconnectAbortListener = void 0;
-      if (listeners.length === 0) {
+      this.activeStreamControllers.delete(sessionId);
+      if (listenerCleanups.length === 0) {
         return;
       }
-      for (const { event, listener } of listeners) {
-        this.agentEventBus.off(
-          event,
-          listener
-        );
+      for (const removeListener of listenerCleanups) {
+        removeListener();
       }
-      listeners.length = 0;
-      this.activeStreamControllers.delete(sessionId);
+      listenerCleanups.length = 0;
     };
+    try {
+      const existingSession = await this.sessionManager.getSession(sessionId, false);
+      if (existingSession?.isBusy?.()) {
+        throw AgentError.sessionBusy(sessionId);
+      }
+    } catch (error) {
+      cleanupListeners();
+      controller.abort();
+      throw error;
+    }
     if (disconnectSignal) {
       const abortHandler = () => {
         cleanupListeners();
@@ -688,40 +727,32 @@ Either:
       if (data.sessionId !== sessionId) return;
       eventQueue.push({ name: "llm:thinking", ...data });
     };
-    this.agentEventBus.on("llm:thinking", thinkingListener, { signal: cleanupSignal });
-    listeners.push({ event: "llm:thinking", listener: thinkingListener });
+    addStreamingListener("llm:thinking", thinkingListener);
     const chunkListener = (data) => {
       if (data.sessionId !== sessionId) return;
       eventQueue.push({ name: "llm:chunk", ...data });
     };
-    this.agentEventBus.on("llm:chunk", chunkListener, { signal: cleanupSignal });
-    listeners.push({ event: "llm:chunk", listener: chunkListener });
+    addStreamingListener("llm:chunk", chunkListener);
     const responseListener = (data) => {
       if (data.sessionId !== sessionId) return;
       eventQueue.push({ name: "llm:response", ...data });
     };
-    this.agentEventBus.on("llm:response", responseListener, { signal: cleanupSignal });
-    listeners.push({ event: "llm:response", listener: responseListener });
+    addStreamingListener("llm:response", responseListener);
     const toolCallListener = (data) => {
       if (data.sessionId !== sessionId) return;
       eventQueue.push({ name: "llm:tool-call", ...data });
     };
-    this.agentEventBus.on("llm:tool-call", toolCallListener, { signal: cleanupSignal });
-    listeners.push({ event: "llm:tool-call", listener: toolCallListener });
+    addStreamingListener("llm:tool-call", toolCallListener);
     const toolCallPartialListener = (data) => {
       if (data.sessionId !== sessionId) return;
       eventQueue.push({ name: "llm:tool-call-partial", ...data });
     };
-    this.agentEventBus.on("llm:tool-call-partial", toolCallPartialListener, {
-      signal: cleanupSignal
-    });
-    listeners.push({ event: "llm:tool-call-partial", listener: toolCallPartialListener });
+    addStreamingListener("llm:tool-call-partial", toolCallPartialListener);
     const toolResultListener = (data) => {
       if (data.sessionId !== sessionId) return;
       eventQueue.push({ name: "llm:tool-result", ...data });
     };
-    this.agentEventBus.on("llm:tool-result", toolResultListener, { signal: cleanupSignal });
-    listeners.push({ event: "llm:tool-result", listener: toolResultListener });
+    addStreamingListener("llm:tool-result", toolResultListener);
     const errorListener = (data) => {
       if (data.sessionId !== sessionId) return;
       if (data.recoverable !== true) {
@@ -729,117 +760,70 @@ Either:
       }
       eventQueue.push({ name: "llm:error", ...data });
     };
-    this.agentEventBus.on("llm:error", errorListener, { signal: cleanupSignal });
-    listeners.push({ event: "llm:error", listener: errorListener });
+    addStreamingListener("llm:error", errorListener);
     const unsupportedInputListener = (data) => {
       if (data.sessionId !== sessionId) return;
       eventQueue.push({ name: "llm:unsupported-input", ...data });
     };
-    this.agentEventBus.on("llm:unsupported-input", unsupportedInputListener, {
-      signal: cleanupSignal
-    });
-    listeners.push({ event: "llm:unsupported-input", listener: unsupportedInputListener });
+    addStreamingListener("llm:unsupported-input", unsupportedInputListener);
     const titleUpdatedListener = (data) => {
       if (data.sessionId !== sessionId) return;
       eventQueue.push({ name: "session:title-updated", ...data });
     };
-    this.agentEventBus.on("session:title-updated", titleUpdatedListener, {
-      signal: cleanupSignal
-    });
-    listeners.push({ event: "session:title-updated", listener: titleUpdatedListener });
+    addStreamingListener("session:title-updated", titleUpdatedListener);
     const approvalRequestListener = (data) => {
       if (data.sessionId !== sessionId) return;
       eventQueue.push({ name: "approval:request", ...data });
     };
-    this.agentEventBus.on("approval:request", approvalRequestListener, {
-      signal: cleanupSignal
-    });
-    listeners.push({ event: "approval:request", listener: approvalRequestListener });
+    addStreamingListener("approval:request", approvalRequestListener);
     const approvalResponseListener = (data) => {
       if (data.sessionId !== sessionId) return;
       eventQueue.push({ name: "approval:response", ...data });
     };
-    this.agentEventBus.on("approval:response", approvalResponseListener, {
-      signal: cleanupSignal
-    });
-    listeners.push({ event: "approval:response", listener: approvalResponseListener });
+    addStreamingListener("approval:response", approvalResponseListener);
     const toolRunningListener = (data) => {
       if (data.sessionId !== sessionId) return;
       eventQueue.push({ name: "tool:running", ...data });
     };
-    this.agentEventBus.on("tool:running", toolRunningListener, {
-      signal: cleanupSignal
-    });
-    listeners.push({ event: "tool:running", listener: toolRunningListener });
+    addStreamingListener("tool:running", toolRunningListener);
     const contextCompactingListener = (data) => {
       if (data.sessionId !== sessionId) return;
       eventQueue.push({ name: "context:compacting", ...data });
     };
-    this.agentEventBus.on("context:compacting", contextCompactingListener, {
-      signal: cleanupSignal
-    });
-    listeners.push({ event: "context:compacting", listener: contextCompactingListener });
+    addStreamingListener("context:compacting", contextCompactingListener);
     const contextCompactedListener = (data) => {
       if (data.sessionId !== sessionId) return;
       eventQueue.push({ name: "context:compacted", ...data });
     };
-    this.agentEventBus.on("context:compacted", contextCompactedListener, {
-      signal: cleanupSignal
-    });
-    listeners.push({ event: "context:compacted", listener: contextCompactedListener });
+    addStreamingListener("context:compacted", contextCompactedListener);
     const messageQueuedListener = (data) => {
       if (data.sessionId !== sessionId) return;
       eventQueue.push({ name: "message:queued", ...data });
     };
-    this.agentEventBus.on("message:queued", messageQueuedListener, {
-      signal: cleanupSignal
-    });
-    listeners.push({ event: "message:queued", listener: messageQueuedListener });
+    addStreamingListener("message:queued", messageQueuedListener);
     const messageDequeuedListener = (data) => {
       if (data.sessionId !== sessionId) return;
       eventQueue.push({ name: "message:dequeued", ...data });
     };
-    this.agentEventBus.on("message:dequeued", messageDequeuedListener, {
-      signal: cleanupSignal
-    });
-    listeners.push({ event: "message:dequeued", listener: messageDequeuedListener });
+    addStreamingListener("message:dequeued", messageDequeuedListener);
     const serviceEventListener = (data) => {
       if (data.sessionId !== sessionId) return;
       eventQueue.push({ name: "service:event", ...data });
     };
-    this.agentEventBus.on("service:event", serviceEventListener, {
-      signal: cleanupSignal
-    });
-    listeners.push({ event: "service:event", listener: serviceEventListener });
+    addStreamingListener("service:event", serviceEventListener);
     const runCompleteListener = (data) => {
       if (data.sessionId !== sessionId) return;
       sawRunCompleteEvent = true;
       eventQueue.push({ name: "run:complete", ...data });
       completed = true;
     };
-    this.agentEventBus.on("run:complete", runCompleteListener, {
-      signal: cleanupSignal
-    });
-    listeners.push({ event: "run:complete", listener: runCompleteListener });
+    addStreamingListener("run:complete", runCompleteListener);
     (async () => {
-      const activeContext = context.active();
       const activeSpan = trace.getActiveSpan();
       if (activeSpan) {
         activeSpan.setAttribute("sessionId", sessionId);
       }
-      const existingBaggage = propagation.getBaggage(activeContext);
-      const baggageEntries = {};
-      if (existingBaggage) {
-        existingBaggage.getAllEntries().forEach(([key, entry]) => {
-          baggageEntries[key] = { ...entry };
-        });
-      }
-      baggageEntries.sessionId = { ...baggageEntries.sessionId, value: sessionId };
-      const updatedContext = propagation.setBaggage(
-        activeContext,
-        propagation.createBaggage(baggageEntries)
-      );
-      await context.with(updatedContext, async () => {
+      await context.with(runContext.telemetryContext, async () => {
         try {
           const llmConfig = this.stateManager.getLLMConfig(sessionId);
           const textParts = contentParts.filter(
@@ -985,10 +969,10 @@ Either:
           }
           validatePromptContentParts(contentParts);
           const session = await this.sessionManager.getSession(sessionId) || await this.sessionManager.createSession(sessionId);
-          const _streamResult = await session.stream(
-            contentParts,
-            signal ? { signal } : void 0
-          );
+          await session.stream(contentParts, {
+            ...signal ? { signal } : {},
+            runContext
+          });
           this.sessionManager.incrementMessageCount(session.id).catch(
             (error) => this.logger.warn(
               `Failed to increment message count: ${error instanceof Error ? error.message : String(error)}`
@@ -1012,7 +996,8 @@ Either:
             error,
             recoverable: false,
             context: "run_failed",
-            sessionId
+            sessionId,
+            ...executionContext !== void 0 && { hostRuntime: executionContext }
           };
           eventQueue.push(errorEvent);
         }
@@ -1058,7 +1043,7 @@ Either:
   async isSessionBusy(sessionId) {
     this.ensureStarted();
     const session = await this.sessionManager.getSession(sessionId, false);
-    return session?.isBusy() ?? false;
+    return session?.isBusy?.() ?? false;
   }
   /**
    * Queue a message for processing when a session is busy.

package/dist/agent/error-codes.cjs

@@ -27,6 +27,7 @@ var AgentErrorCode = /* @__PURE__ */ ((AgentErrorCode2) => {
   AgentErrorCode2["STOPPED"] = "agent_stopped";
   AgentErrorCode2["INITIALIZATION_FAILED"] = "agent_initialization_failed";
   AgentErrorCode2["SWITCH_IN_PROGRESS"] = "agent_switch_in_progress";
+  AgentErrorCode2["SESSION_BUSY"] = "agent_session_busy";
   AgentErrorCode2["NO_CONFIG_PATH"] = "agent_no_config_path";
   AgentErrorCode2["INVALID_CONFIG"] = "agent_invalid_config";
   AgentErrorCode2["API_VALIDATION_ERROR"] = "agent_api_validation_error";

package/dist/agent/error-codes.d.ts

@@ -9,6 +9,7 @@ export declare enum AgentErrorCode {
     STOPPED = "agent_stopped",
     INITIALIZATION_FAILED = "agent_initialization_failed",
     SWITCH_IN_PROGRESS = "agent_switch_in_progress",
+    SESSION_BUSY = "agent_session_busy",
     NO_CONFIG_PATH = "agent_no_config_path",
     INVALID_CONFIG = "agent_invalid_config",
     API_VALIDATION_ERROR = "agent_api_validation_error",

package/dist/agent/error-codes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../src/agent/error-codes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,oBAAY,cAAc;IAEtB,WAAW,sBAAsB;IACjC,eAAe,0BAA0B;IACzC,OAAO,kBAAkB;IACzB,qBAAqB,gCAAgC;IACrD,kBAAkB,6BAA6B;IAG/C,cAAc,yBAAyB;IACvC,cAAc,yBAAyB;IAGvC,oBAAoB,+BAA+B;IAGnD,aAAa,wBAAwB;CACxC"}
+{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../src/agent/error-codes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,oBAAY,cAAc;IAEtB,WAAW,sBAAsB;IACjC,eAAe,0BAA0B;IACzC,OAAO,kBAAkB;IACzB,qBAAqB,gCAAgC;IACrD,kBAAkB,6BAA6B;IAC/C,YAAY,uBAAuB;IAGnC,cAAc,yBAAyB;IACvC,cAAc,yBAAyB;IAGvC,oBAAoB,+BAA+B;IAGnD,aAAa,wBAAwB;CACxC"}

package/dist/agent/error-codes.js

@@ -5,6 +5,7 @@ var AgentErrorCode = /* @__PURE__ */ ((AgentErrorCode2) => {
   AgentErrorCode2["STOPPED"] = "agent_stopped";
   AgentErrorCode2["INITIALIZATION_FAILED"] = "agent_initialization_failed";
   AgentErrorCode2["SWITCH_IN_PROGRESS"] = "agent_switch_in_progress";
+  AgentErrorCode2["SESSION_BUSY"] = "agent_session_busy";
   AgentErrorCode2["NO_CONFIG_PATH"] = "agent_no_config_path";
   AgentErrorCode2["INVALID_CONFIG"] = "agent_invalid_config";
   AgentErrorCode2["API_VALIDATION_ERROR"] = "agent_api_validation_error";

package/dist/agent/errors.cjs

@@ -77,6 +77,19 @@ class AgentError {
       "Wait for the current switch operation to complete before starting a new one"
     );
   }
+  /**
+   * Session already processing a run
+   */
+  static sessionBusy(sessionId) {
+    return new import_DextoRuntimeError.DextoRuntimeError(
+      import_error_codes.AgentErrorCode.SESSION_BUSY,
+      import_types.ErrorScope.AGENT,
+      import_types.ErrorType.CONFLICT,
+      `Session '${sessionId}' is already processing a message`,
+      { sessionId },
+      "Wait for the current run to finish or queue the next message"
+    );
+  }
   /**
    * Agent initialization failed
    */

package/dist/agent/errors.d.ts

@@ -21,6 +21,12 @@ export declare class AgentError {
      * Agent switch in progress
      */
     static switchInProgress(): DextoRuntimeError<undefined>;
+    /**
+     * Session already processing a run
+     */
+    static sessionBusy(sessionId: string): DextoRuntimeError<{
+        sessionId: string;
+    }>;
     /**
      * Agent initialization failed
      */

package/dist/agent/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/agent/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAInE;;;;GAIG;AACH,qBAAa,UAAU;IACnB;;OAEG;IACH,MAAM,CAAC,UAAU;IAWjB;;OAEG;IACH,MAAM,CAAC,cAAc;IAWrB;;OAEG;IACH,MAAM,CAAC,OAAO;IAWd;;OAEG;IACH,MAAM,CAAC,gBAAgB;IAWvB;;OAEG;IACH,MAAM,CAAC,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO;IAW7D;;OAEG;IACH,MAAM,CAAC,YAAY;IAWnB;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO;IAW5D;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO;CAUzD"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/agent/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAInE;;;;GAIG;AACH,qBAAa,UAAU;IACnB;;OAEG;IACH,MAAM,CAAC,UAAU;IAWjB;;OAEG;IACH,MAAM,CAAC,cAAc;IAWrB;;OAEG;IACH,MAAM,CAAC,OAAO;IAWd;;OAEG;IACH,MAAM,CAAC,gBAAgB;IAWvB;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM;;;IAWpC;;OAEG;IACH,MAAM,CAAC,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO;IAW7D;;OAEG;IACH,MAAM,CAAC,YAAY;IAWnB;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO;IAW5D;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO;CAUzD"}

package/dist/agent/errors.js

@@ -55,6 +55,19 @@ class AgentError {
       "Wait for the current switch operation to complete before starting a new one"
     );
   }
+  /**
+   * Session already processing a run
+   */
+  static sessionBusy(sessionId) {
+    return new DextoRuntimeError(
+      AgentErrorCode.SESSION_BUSY,
+      ErrorScope.AGENT,
+      ErrorType.CONFLICT,
+      `Session '${sessionId}' is already processing a message`,
+      { sessionId },
+      "Wait for the current run to finish or queue the next message"
+    );
+  }
   /**
    * Agent initialization failed
    */

package/dist/agent/index.d.ts

@@ -5,6 +5,7 @@ export * from './errors.js';
 export * from './error-codes.js';
 export type { DextoAgentOptions } from './agent-options.js';
 export type { AgentRuntimeSettings, DextoAgentConfigInput } from './runtime-config.js';
+export type { HostRuntimeContext, HostRuntimeIds } from '../runtime/index.js';
 export type { ContentInput, GenerateOptions, GenerateResponse, StreamOptions, AgentToolCall, } from './types.js';
 export type { StreamingEvent, StreamingEventName, STREAMING_EVENTS } from '../events/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/agent/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EACH,eAAe,EACf,oBAAoB,EACpB,KAAK,SAAS,EACd,KAAK,kBAAkB,GAC1B,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,YAAY,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAGvF,YAAY,EACR,YAAY,EACZ,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,aAAa,GAChB,MAAM,YAAY,CAAC;AAGpB,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EACH,eAAe,EACf,oBAAoB,EACpB,KAAK,SAAS,EACd,KAAK,kBAAkB,GAC1B,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,YAAY,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AACvF,YAAY,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG9E,YAAY,EACR,YAAY,EACZ,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,aAAa,GAChB,MAAM,YAAY,CAAC;AAGpB,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/agent/schemas.cjs

@@ -39,7 +39,7 @@ const OAuth2FlowSchema = import_zod.z.object({
   authorizationUrl: import_zod.z.string().url().optional().describe("Authorization URL for the flow"),
   tokenUrl: import_zod.z.string().url().optional().describe("Token URL for the flow"),
   refreshUrl: import_zod.z.string().url().optional().describe("Refresh URL for the flow"),
-  scopes: import_zod.z.record(import_zod.z.string()).describe("Available scopes for the OAuth2 flow")
+  scopes: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).describe("Available scopes for the OAuth2 flow")
 }).strict();
 const OAuth2SecurityScheme = import_zod.z.object({
   type: import_zod.z.literal("oauth2").describe("Security scheme type"),
@@ -112,7 +112,7 @@ const AgentCardSchema = import_zod.z.object({
       inputModes: import_zod.z.array(import_zod.z.string()).optional().default(["text/plain"]).describe("Skill-specific input MIME types"),
       outputModes: import_zod.z.array(import_zod.z.string()).optional().default(["text/plain"]).describe("Skill-specific output MIME types")
     }).strict()
-  ).default([
+  ).prefault([
     {
       id: "chat_with_agent",
       name: "chat_with_agent",
@@ -143,9 +143,9 @@ const AgentCardSchema = import_zod.z.object({
     streaming: import_zod.z.boolean().optional().default(true).describe("Supports streaming responses"),
     pushNotifications: import_zod.z.boolean().optional().describe("Supports push notifications"),
     stateTransitionHistory: import_zod.z.boolean().optional().default(false).describe("Provides state transition history")
-  }).strict().default({}).describe("Agent capabilities and features"),
-  securitySchemes: import_zod.z.record(SecuritySchemeSchema).optional().describe("Map of security scheme definitions (A2A format)"),
-  security: import_zod.z.array(import_zod.z.record(import_zod.z.array(import_zod.z.string()))).optional().describe(
+  }).strict().prefault({}).describe("Agent capabilities and features"),
+  securitySchemes: import_zod.z.record(import_zod.z.string(), SecuritySchemeSchema).optional().describe("Map of security scheme definitions (A2A format)"),
+  security: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.array(import_zod.z.string()))).optional().describe(
     "Security requirements (array of security scheme references with required scopes)"
   ),
   supportsAuthenticatedExtendedCard: import_zod.z.boolean().optional().describe("Whether extended card is available with authentication"),