@dexto/core 1.2.3 → 1.2.5

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

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/agent/schemas.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/agent/schemas.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAmFM,CAAC;AAGrC,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/agent/schemas.js

@@ -1,57 +1,109 @@
 import "../chunk-C6A6W6XS.js";
 import { LLMConfigSchema } from "../llm/schemas.js";
+import { LoggerConfigSchema } from "../logger/index.js";
 import { ServerConfigsSchema as McpServersConfigSchema } from "../mcp/schemas.js";
 import { SessionConfigSchema } from "../session/schemas.js";
 import { StorageSchema } from "../storage/schemas.js";
 import { SystemPromptConfigSchema } from "../systemPrompt/schemas.js";
-import { InternalToolsSchema, ToolConfirmationConfigSchema } from "../tools/schemas.js";
+import {
+  InternalToolsSchema,
+  ToolConfirmationConfigSchema,
+  ElicitationConfigSchema
+} from "../tools/schemas.js";
 import { z } from "zod";
 import { InternalResourcesSchema } from "../resources/schemas.js";
 import { StarterPromptsSchema } from "../prompts/schemas.js";
 import { PluginsConfigSchema } from "../plugins/schemas.js";
 import { OtelConfigurationSchema } from "../telemetry/schemas.js";
-const AgentCardSchema = z.object({
-  name: z.string(),
-  // No default, must be provided by context
-  description: z.string().default(
-    "Dexto is an AI assistant capable of chat and task delegation, accessible via multiple protocols."
-  ),
-  url: z.string().url(),
-  // No default, must be provided by context
-  provider: z.object({
-    organization: z.string(),
-    url: z.string().url()
-  }).optional(),
-  // Remains optional, undefined if not provided
-  version: z.string(),
-  // No default, must be provided by context
-  documentationUrl: z.string().url().optional(),
-  // Remains optional, undefined if not provided
-  capabilities: z.object({
-    streaming: z.boolean().optional().default(true),
-    pushNotifications: z.boolean().optional(),
-    // Default is context-dependent (webSubscriber)
-    stateTransitionHistory: z.boolean().optional().default(false)
-  }).strict().default({}),
-  // Add default for the capabilities object itself
+const ApiKeySecurityScheme = z.object({
+  type: z.literal("apiKey").describe("Security scheme type"),
+  name: z.string().describe("Name of the header/query/cookie parameter"),
+  in: z.enum(["query", "header", "cookie"]).describe("Location of API key"),
+  description: z.string().optional().describe("Description of the security scheme")
+}).strict();
+const HttpSecurityScheme = z.object({
+  type: z.literal("http").describe("Security scheme type"),
+  scheme: z.string().describe("HTTP authorization scheme (e.g., basic, bearer)"),
+  bearerFormat: z.string().optional().describe("Hint for bearer token format"),
+  description: z.string().optional().describe("Description of the security scheme")
+}).strict();
+const OAuth2FlowSchema = z.object({
+  authorizationUrl: z.string().url().optional().describe("Authorization URL for the flow"),
+  tokenUrl: z.string().url().optional().describe("Token URL for the flow"),
+  refreshUrl: z.string().url().optional().describe("Refresh URL for the flow"),
+  scopes: z.record(z.string()).describe("Available scopes for the OAuth2 flow")
+}).strict();
+const OAuth2SecurityScheme = z.object({
+  type: z.literal("oauth2").describe("Security scheme type"),
+  flows: z.object({
+    implicit: OAuth2FlowSchema.optional(),
+    password: OAuth2FlowSchema.optional(),
+    clientCredentials: OAuth2FlowSchema.optional(),
+    authorizationCode: OAuth2FlowSchema.optional()
+  }).strict().describe("OAuth2 flow configurations"),
+  description: z.string().optional().describe("Description of the security scheme")
+}).strict();
+const OpenIdConnectSecurityScheme = z.object({
+  type: z.literal("openIdConnect").describe("Security scheme type"),
+  openIdConnectUrl: z.string().url().describe("OpenID Connect discovery URL"),
+  description: z.string().optional().describe("Description of the security scheme")
+}).strict();
+const MutualTLSSecurityScheme = z.object({
+  type: z.literal("mutualTLS").describe("Security scheme type"),
+  description: z.string().optional().describe("Description of the security scheme")
+}).strict();
+const SecuritySchemeSchema = z.discriminatedUnion("type", [
+  ApiKeySecurityScheme,
+  HttpSecurityScheme,
+  OAuth2SecurityScheme,
+  OpenIdConnectSecurityScheme,
+  MutualTLSSecurityScheme
+]);
+const AgentCardSignatureSchema = z.object({
+  protected: z.string().describe("Base64url-encoded JWS Protected Header"),
+  signature: z.string().describe("Base64url-encoded JWS Signature")
+}).strict();
+const DextoMetadataSchema = z.object({
   authentication: z.object({
-    schemes: z.array(z.string()).default([]),
-    credentials: z.string().optional()
-    // Remains optional
-  }).strict().default({}),
-  // Add default for the authentication object itself
-  defaultInputModes: z.array(z.string()).default(["application/json", "text/plain"]),
-  defaultOutputModes: z.array(z.string()).default(["application/json", "text/event-stream", "text/plain"]),
+    schemes: z.array(z.string()).default([]).describe("Legacy authentication schemes (deprecated: use securitySchemes)"),
+    credentials: z.string().optional().describe("Credentials information")
+  }).strict().optional().describe("Legacy authentication configuration"),
+  delegation: z.object({
+    protocol: z.enum(["dexto-v1", "http-simple", "a2a-jsonrpc", "mcp-http"]).describe("Delegation protocol version"),
+    endpoint: z.string().describe("Delegation endpoint (relative path or full URL)"),
+    supportsSession: z.boolean().describe("Whether agent supports stateful sessions"),
+    supportsStreaming: z.boolean().optional().describe("Whether agent supports streaming responses")
+  }).strict().optional().describe("Delegation protocol information for agent-to-agent communication"),
+  owner: z.object({
+    userId: z.string().describe("Unique user identifier from auth system"),
+    username: z.string().describe("Display name"),
+    email: z.string().email().max(254).optional().describe(
+      "Optional user email (WARNING: publicly readable via .well-known/agent.json if provided)"
+    )
+  }).strict().optional().describe("Agent owner information (for multi-tenant deployments)")
+}).strict();
+const AgentCardSchema = z.object({
+  // ────────────────────────────────────────────────────────
+  // A2A Protocol Required Fields
+  // ────────────────────────────────────────────────────────
+  protocolVersion: z.string().default("0.3.0").describe('A2A protocol version (e.g., "0.3.0")'),
+  name: z.string().describe("Human-readable agent name"),
+  description: z.string().describe("Detailed description of agent purpose and capabilities"),
+  url: z.string().url().describe("Primary endpoint URL for the agent"),
+  version: z.string().describe("Agent version (semantic versioning recommended)"),
+  preferredTransport: z.enum(["JSONRPC", "GRPC", "HTTP+JSON"]).default("JSONRPC").describe("Primary transport protocol for communication"),
+  defaultInputModes: z.array(z.string()).default(["application/json", "text/plain"]).describe("Supported input MIME types"),
+  defaultOutputModes: z.array(z.string()).default(["application/json", "text/event-stream", "text/plain"]).describe("Supported output MIME types"),
   skills: z.array(
     z.object({
-      id: z.string(),
-      name: z.string(),
-      description: z.string(),
-      tags: z.array(z.string()),
-      examples: z.array(z.string()).optional(),
-      inputModes: z.array(z.string()).optional().default(["text/plain"]),
-      outputModes: z.array(z.string()).optional().default(["text/plain"])
-    })
+      id: z.string().describe("Unique skill identifier"),
+      name: z.string().describe("Human-readable skill name"),
+      description: z.string().describe("Detailed skill description"),
+      tags: z.array(z.string()).describe("Searchable tags for discovery"),
+      examples: z.array(z.string()).optional().describe("Example use cases or queries"),
+      inputModes: z.array(z.string()).optional().default(["text/plain"]).describe("Skill-specific input MIME types"),
+      outputModes: z.array(z.string()).optional().default(["text/plain"]).describe("Skill-specific output MIME types")
+    }).strict()
   ).default([
     {
       id: "chat_with_agent",
@@ -62,47 +114,98 @@ const AgentCardSchema = z.object({
         `Send a JSON-RPC request to /mcp with method: "chat_with_agent" and params: {"message":"Your query..."}`,
         "Alternatively, use a compatible MCP client library."
       ]
-      // inputModes and outputModes will use their own defaults if not specified here
     }
-  ])
+  ]).describe("Agent capabilities/skills"),
+  // ────────────────────────────────────────────────────────
+  // A2A Protocol Optional Fields
+  // ────────────────────────────────────────────────────────
+  provider: z.object({
+    organization: z.string().describe("Provider organization name"),
+    url: z.string().url().describe("Provider organization URL")
+  }).strict().optional().describe("Agent provider information"),
+  iconUrl: z.string().url().optional().describe("URL to agent icon/logo (for UI display)"),
+  documentationUrl: z.string().url().optional().describe("URL to agent documentation"),
+  additionalInterfaces: z.array(
+    z.object({
+      url: z.string().url().describe("Endpoint URL"),
+      transport: z.enum(["JSONRPC", "GRPC", "HTTP+JSON"]).describe("Transport protocol")
+    }).strict()
+  ).optional().describe("Additional interfaces/transports supported by the agent"),
+  capabilities: z.object({
+    streaming: z.boolean().optional().default(true).describe("Supports streaming responses"),
+    pushNotifications: z.boolean().optional().describe("Supports push notifications"),
+    stateTransitionHistory: z.boolean().optional().default(false).describe("Provides state transition history")
+  }).strict().default({}).describe("Agent capabilities and features"),
+  securitySchemes: z.record(SecuritySchemeSchema).optional().describe("Map of security scheme definitions (A2A format)"),
+  security: z.array(z.record(z.array(z.string()))).optional().describe(
+    "Security requirements (array of security scheme references with required scopes)"
+  ),
+  supportsAuthenticatedExtendedCard: z.boolean().optional().describe("Whether extended card is available with authentication"),
+  signatures: z.array(AgentCardSignatureSchema).optional().describe("JSON Web Signatures for verifying AgentCard integrity"),
+  metadata: z.object({
+    dexto: DextoMetadataSchema.optional().describe("Dexto-specific extension metadata")
+  }).passthrough().optional().describe("Extension-specific metadata (namespaced by extension name)")
 }).strict();
 const AgentConfigSchema = z.object({
-  agentCard: AgentCardSchema.describe("Configuration for the agent card").optional(),
-  greeting: z.string().max(500).optional().describe("Default greeting text to show when a chat starts (for UI consumption)"),
+  // ========================================
+  // REQUIRED FIELDS (user must provide or schema validation fails)
+  // ========================================
   systemPrompt: SystemPromptConfigSchema.describe(
     "System prompt: string shorthand or structured config"
   ),
-  mcpServers: McpServersConfigSchema.default({}).describe(
-    "Configurations for MCP (Model Context Protocol) servers used by the agent"
-  ),
-  internalTools: InternalToolsSchema,
   llm: LLMConfigSchema.describe("Core LLM configuration for the agent"),
-  // Storage configuration
-  storage: StorageSchema.default({
+  // ========================================
+  // OPTIONAL FEATURES (undefined if not provided)
+  // ========================================
+  agentCard: AgentCardSchema.describe("Configuration for the agent card").optional(),
+  greeting: z.string().max(500).describe("Default greeting text to show when a chat starts (for UI consumption)").optional(),
+  telemetry: OtelConfigurationSchema.describe(
+    "OpenTelemetry configuration for distributed tracing and observability"
+  ).optional(),
+  // ========================================
+  // FIELDS WITH DEFAULTS (always present after parsing)
+  // ========================================
+  agentId: z.string().describe(
+    "Unique identifier for this agent instance - CLI enrichment derives from agentCard.name or filename"
+  ).default("default-agent"),
+  mcpServers: McpServersConfigSchema.describe(
+    "Configurations for MCP (Model Context Protocol) servers used by the agent"
+  ).default({}),
+  internalTools: InternalToolsSchema.describe(
+    "Internal tools configuration (read-file, write-file, bash-exec, etc.)"
+  ).default([]),
+  logger: LoggerConfigSchema.describe(
+    "Logger configuration with multi-transport support (file, console, remote) - CLI enrichment adds per-agent file transport"
+  ).default({
+    level: "info",
+    transports: [{ type: "console", colorize: true }]
+  }),
+  storage: StorageSchema.describe(
+    "Storage configuration for cache, database, and blob storage - defaults to in-memory, CLI enrichment provides filesystem paths"
+  ).default({
     cache: { type: "in-memory" },
     database: { type: "in-memory" },
-    blob: { type: "local" }
-  }).describe("Storage configuration for cache, database, and blob storage"),
-  sessions: SessionConfigSchema.default({}).describe("Session management configuration"),
-  toolConfirmation: ToolConfirmationConfigSchema.default({}).describe(
+    blob: { type: "in-memory" }
+  }),
+  sessions: SessionConfigSchema.describe("Session management configuration").default({}),
+  toolConfirmation: ToolConfirmationConfigSchema.describe(
     "Tool confirmation and approval configuration"
+  ).default({}),
+  elicitation: ElicitationConfigSchema.default({}).describe(
+    "Elicitation configuration for user input requests (ask_user tool and MCP server elicitations). Independent from toolConfirmation mode."
   ),
-  // Internal resources configuration (filesystem, etc.)
   internalResources: InternalResourcesSchema.describe(
     "Configuration for internal resources (filesystem, etc.)"
   ).default([]),
-  // Agent-specific starter prompts configuration (used by WebUI and PromptManager)
-  starterPrompts: StarterPromptsSchema,
-  // Plugin configuration
+  starterPrompts: StarterPromptsSchema.describe(
+    "Agent-specific starter prompts configuration (used by WebUI and PromptManager)"
+  ).default([]),
   plugins: PluginsConfigSchema.describe(
     "Plugin system configuration for built-in and custom plugins"
-  ).default({}),
-  // Telemetry configuration
-  telemetry: OtelConfigurationSchema.describe(
-    "OpenTelemetry configuration for distributed tracing and observability"
-  ).optional()
+  ).default({})
 }).strict().describe("Main configuration for an agent, including its LLM and server connections").brand();
 export {
   AgentCardSchema,
-  AgentConfigSchema
+  AgentConfigSchema,
+  SecuritySchemeSchema
 };

package/dist/agent/state-manager.cjs

@@ -21,19 +21,21 @@ __export(state_manager_exports, {
   AgentStateManager: () => AgentStateManager
 });
 module.exports = __toCommonJS(state_manager_exports);
-var import_logger = require("../logger/index.js");
+var import_types = require("../logger/v2/types.js");
 class AgentStateManager {
   /**
    * Initialize AgentStateManager from a validated static configuration.
    *
    * @param staticConfig The validated configuration from DextoAgent
    * @param agentEventBus The agent event bus for emitting state change events
+   * @param logger Logger instance for this agent
    */
-  constructor(staticConfig, agentEventBus) {
+  constructor(staticConfig, agentEventBus, logger) {
     this.agentEventBus = agentEventBus;
     this.baselineConfig = structuredClone(staticConfig);
     this.runtimeConfig = structuredClone(staticConfig);
-    import_logger.logger.debug("AgentStateManager initialized", {
+    this.logger = logger.createChild(import_types.DextoLogComponent.AGENT);
+    this.logger.debug("AgentStateManager initialized", {
       staticConfigKeys: Object.keys(this.baselineConfig),
       mcpServerCount: Object.keys(this.runtimeConfig.mcpServers).length
     });
@@ -41,6 +43,7 @@ class AgentStateManager {
   runtimeConfig;
   baselineConfig;
   sessionOverrides = /* @__PURE__ */ new Map();
+  logger;
   // ============= GETTERS =============
   /**
    * Get runtime configuration for a session (includes session overrides if sessionId provided)
@@ -75,13 +78,13 @@ class AgentStateManager {
     } else {
       this.runtimeConfig.llm = validatedConfig;
     }
-    this.agentEventBus.emit("dexto:stateChanged", {
+    this.agentEventBus.emit("state:changed", {
       field: "llm",
       oldValue,
       newValue: validatedConfig,
       ...sessionId && { sessionId }
     });
-    import_logger.logger.info("LLM config updated", {
+    this.logger.info("LLM config updated", {
       sessionId,
       provider: validatedConfig.provider,
       model: validatedConfig.model,
@@ -97,36 +100,38 @@ class AgentStateManager {
    * branded type ensures validation has occurred.
    */
   addMcpServer(serverName, validatedConfig) {
-    import_logger.logger.debug(`Adding/updating MCP server: ${serverName}`);
+    this.logger.debug(`Adding/updating MCP server: ${serverName}`);
     const isUpdate = serverName in this.runtimeConfig.mcpServers;
     this.runtimeConfig.mcpServers[serverName] = validatedConfig;
-    const eventName = isUpdate ? "dexto:mcpServerUpdated" : "dexto:mcpServerAdded";
+    const eventName = isUpdate ? "mcp:server-updated" : "mcp:server-added";
     this.agentEventBus.emit(eventName, { serverName, config: validatedConfig });
-    this.agentEventBus.emit("dexto:stateChanged", {
+    this.agentEventBus.emit("state:changed", {
       field: "mcpServers",
       oldValue: isUpdate ? "updated" : "added",
       newValue: validatedConfig
       // sessionId omitted - MCP servers are global
     });
-    import_logger.logger.info(`MCP server '${serverName}' ${isUpdate ? "updated" : "added"} successfully`);
+    this.logger.info(
+      `MCP server '${serverName}' ${isUpdate ? "updated" : "added"} successfully`
+    );
   }
   /**
    * Remove an MCP server configuration at runtime.
    */
   removeMcpServer(serverName) {
-    import_logger.logger.debug(`Removing MCP server: ${serverName}`);
+    this.logger.debug(`Removing MCP server: ${serverName}`);
     if (serverName in this.runtimeConfig.mcpServers) {
       delete this.runtimeConfig.mcpServers[serverName];
-      this.agentEventBus.emit("dexto:mcpServerRemoved", { serverName });
-      this.agentEventBus.emit("dexto:stateChanged", {
+      this.agentEventBus.emit("mcp:server-removed", { serverName });
+      this.agentEventBus.emit("state:changed", {
         field: "mcpServers",
         oldValue: "removed",
         newValue: void 0
         // sessionId omitted - MCP servers are global
       });
-      import_logger.logger.info(`MCP server '${serverName}' removed successfully`);
+      this.logger.info(`MCP server '${serverName}' removed successfully`);
     } else {
-      import_logger.logger.warn(`MCP server '${serverName}' not found for removal`);
+      this.logger.warn(`MCP server '${serverName}' not found for removal`);
     }
   }
   // ============= SESSION MANAGEMENT =============
@@ -135,7 +140,7 @@ class AgentStateManager {
    */
   setSessionOverride(sessionId, override) {
     this.sessionOverrides.set(sessionId, override);
-    this.agentEventBus.emit("dexto:sessionOverrideSet", {
+    this.agentEventBus.emit("session:override-set", {
       sessionId,
       override: structuredClone(override)
     });
@@ -153,8 +158,8 @@ class AgentStateManager {
     const hadOverride = this.sessionOverrides.has(sessionId);
     this.sessionOverrides.delete(sessionId);
     if (hadOverride) {
-      this.agentEventBus.emit("dexto:sessionOverrideCleared", { sessionId });
-      import_logger.logger.info("Session override cleared", { sessionId });
+      this.agentEventBus.emit("session:override-cleared", { sessionId });
+      this.logger.info("Session override cleared", { sessionId });
     }
   }
   /**
@@ -164,10 +169,10 @@ class AgentStateManager {
     const sessionIds = Array.from(this.sessionOverrides.keys());
     this.sessionOverrides.clear();
     sessionIds.forEach((sessionId) => {
-      this.agentEventBus.emit("dexto:sessionOverrideCleared", { sessionId });
+      this.agentEventBus.emit("session:override-cleared", { sessionId });
     });
     if (sessionIds.length > 0) {
-      import_logger.logger.info("All session overrides cleared", { clearedSessions: sessionIds });
+      this.logger.info("All session overrides cleared", { clearedSessions: sessionIds });
     }
   }
   // ============= CONFIG EXPORT =============
@@ -182,10 +187,10 @@ class AgentStateManager {
       systemPrompt: this.runtimeConfig.systemPrompt,
       mcpServers: structuredClone(this.runtimeConfig.mcpServers)
     };
-    this.agentEventBus.emit("dexto:stateExported", {
+    this.agentEventBus.emit("state:exported", {
       config: exportedConfig
     });
-    import_logger.logger.info("Runtime state exported as config", {
+    this.logger.info("Runtime state exported as config", {
       exportedConfig
     });
     return exportedConfig;
@@ -196,8 +201,8 @@ class AgentStateManager {
   resetToBaseline() {
     this.runtimeConfig = structuredClone(this.baselineConfig);
     this.clearAllSessionOverrides();
-    this.agentEventBus.emit("dexto:stateReset", { toConfig: this.baselineConfig });
-    import_logger.logger.info("Runtime state reset to baseline config");
+    this.agentEventBus.emit("state:reset", { toConfig: this.baselineConfig });
+    this.logger.info("Runtime state reset to baseline config");
   }
   // ============= CONVENIENCE GETTERS FOR USED FUNCTIONALITY =============
   /**

package/dist/agent/state-manager.d.ts

@@ -1,3 +1,4 @@
+import type { IDextoLogger } from '../logger/v2/types.js';
 import type { ValidatedAgentConfig } from './schemas.js';
 import type { ValidatedLLMConfig } from '../llm/schemas.js';
 import type { ValidatedMcpServerConfig } from '../mcp/schemas.js';
@@ -27,13 +28,15 @@ export declare class AgentStateManager {
     private runtimeConfig;
     private readonly baselineConfig;
     private sessionOverrides;
+    private logger;
     /**
      * Initialize AgentStateManager from a validated static configuration.
      *
      * @param staticConfig The validated configuration from DextoAgent
      * @param agentEventBus The agent event bus for emitting state change events
+     * @param logger Logger instance for this agent
      */
-    constructor(staticConfig: ValidatedAgentConfig, agentEventBus: AgentEventBus);
+    constructor(staticConfig: ValidatedAgentConfig, agentEventBus: AgentEventBus, logger: IDextoLogger);
     /**
      * Get runtime configuration for a session (includes session overrides if sessionId provided)
      */

package/dist/agent/state-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state-manager.d.ts","sourceRoot":"","sources":["../../src/agent/state-manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B,iFAAiF;IACjF,GAAG,CAAC,EAAE,kBAAkB,CAAC;CAC5B;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,iBAAiB;IAatB,OAAO,CAAC,aAAa;IAZzB,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAuB;IACtD,OAAO,CAAC,gBAAgB,CAA2C;IAEnE;;;;;OAKG;gBAEC,YAAY,EAAE,oBAAoB,EAC1B,aAAa,EAAE,aAAa;IAaxC;;OAEG;IACI,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC,oBAAoB,CAAC;IAkB3E;;;;;;OAMG;IACI,SAAS,CAAC,eAAe,EAAE,kBAAkB,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IA4B/E;;;;;;OAMG;IACI,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,eAAe,EAAE,wBAAwB,GAAG,IAAI;IAqBxF;;OAEG;IACI,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAsBhD;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAQ1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAI1B;;OAEG;IACI,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAUpD;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAehC;;;OAGG;IACI,cAAc,IAAI,oBAAoB;IAmB7C;;OAEG;IACI,eAAe,IAAI,IAAI;IAW9B;;;OAGG;IACI,YAAY,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC,kBAAkB,CAAC;CAGxE"}
+{"version":3,"file":"state-manager.d.ts","sourceRoot":"","sources":["../../src/agent/state-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B,iFAAiF;IACjF,GAAG,CAAC,EAAE,kBAAkB,CAAC;CAC5B;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,iBAAiB;IAetB,OAAO,CAAC,aAAa;IAdzB,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAuB;IACtD,OAAO,CAAC,gBAAgB,CAA2C;IACnE,OAAO,CAAC,MAAM,CAAe;IAE7B;;;;;;OAMG;gBAEC,YAAY,EAAE,oBAAoB,EAC1B,aAAa,EAAE,aAAa,EACpC,MAAM,EAAE,YAAY;IAcxB;;OAEG;IACI,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC,oBAAoB,CAAC;IAkB3E;;;;;;OAMG;IACI,SAAS,CAAC,eAAe,EAAE,kBAAkB,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IA4B/E;;;;;;OAMG;IACI,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,eAAe,EAAE,wBAAwB,GAAG,IAAI;IAuBxF;;OAEG;IACI,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAsBhD;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAQ1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAI1B;;OAEG;IACI,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAUpD;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAehC;;;OAGG;IACI,cAAc,IAAI,oBAAoB;IAmB7C;;OAEG;IACI,eAAe,IAAI,IAAI;IAW9B;;;OAGG;IACI,YAAY,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC,kBAAkB,CAAC;CAGxE"}

package/dist/agent/state-manager.js

@@ -1,17 +1,19 @@
 import "../chunk-C6A6W6XS.js";
-import { logger } from "../logger/index.js";
+import { DextoLogComponent } from "../logger/v2/types.js";
 class AgentStateManager {
   /**
    * Initialize AgentStateManager from a validated static configuration.
    *
    * @param staticConfig The validated configuration from DextoAgent
    * @param agentEventBus The agent event bus for emitting state change events
+   * @param logger Logger instance for this agent
    */
-  constructor(staticConfig, agentEventBus) {
+  constructor(staticConfig, agentEventBus, logger) {
     this.agentEventBus = agentEventBus;
     this.baselineConfig = structuredClone(staticConfig);
     this.runtimeConfig = structuredClone(staticConfig);
-    logger.debug("AgentStateManager initialized", {
+    this.logger = logger.createChild(DextoLogComponent.AGENT);
+    this.logger.debug("AgentStateManager initialized", {
       staticConfigKeys: Object.keys(this.baselineConfig),
       mcpServerCount: Object.keys(this.runtimeConfig.mcpServers).length
     });
@@ -19,6 +21,7 @@ class AgentStateManager {
   runtimeConfig;
   baselineConfig;
   sessionOverrides = /* @__PURE__ */ new Map();
+  logger;
   // ============= GETTERS =============
   /**
    * Get runtime configuration for a session (includes session overrides if sessionId provided)
@@ -53,13 +56,13 @@ class AgentStateManager {
     } else {
       this.runtimeConfig.llm = validatedConfig;
     }
-    this.agentEventBus.emit("dexto:stateChanged", {
+    this.agentEventBus.emit("state:changed", {
       field: "llm",
       oldValue,
       newValue: validatedConfig,
       ...sessionId && { sessionId }
     });
-    logger.info("LLM config updated", {
+    this.logger.info("LLM config updated", {
       sessionId,
       provider: validatedConfig.provider,
       model: validatedConfig.model,
@@ -75,36 +78,38 @@ class AgentStateManager {
    * branded type ensures validation has occurred.
    */
   addMcpServer(serverName, validatedConfig) {
-    logger.debug(`Adding/updating MCP server: ${serverName}`);
+    this.logger.debug(`Adding/updating MCP server: ${serverName}`);
     const isUpdate = serverName in this.runtimeConfig.mcpServers;
     this.runtimeConfig.mcpServers[serverName] = validatedConfig;
-    const eventName = isUpdate ? "dexto:mcpServerUpdated" : "dexto:mcpServerAdded";
+    const eventName = isUpdate ? "mcp:server-updated" : "mcp:server-added";
     this.agentEventBus.emit(eventName, { serverName, config: validatedConfig });
-    this.agentEventBus.emit("dexto:stateChanged", {
+    this.agentEventBus.emit("state:changed", {
       field: "mcpServers",
       oldValue: isUpdate ? "updated" : "added",
       newValue: validatedConfig
       // sessionId omitted - MCP servers are global
     });
-    logger.info(`MCP server '${serverName}' ${isUpdate ? "updated" : "added"} successfully`);
+    this.logger.info(
+      `MCP server '${serverName}' ${isUpdate ? "updated" : "added"} successfully`
+    );
   }
   /**
    * Remove an MCP server configuration at runtime.
    */
   removeMcpServer(serverName) {
-    logger.debug(`Removing MCP server: ${serverName}`);
+    this.logger.debug(`Removing MCP server: ${serverName}`);
     if (serverName in this.runtimeConfig.mcpServers) {
       delete this.runtimeConfig.mcpServers[serverName];
-      this.agentEventBus.emit("dexto:mcpServerRemoved", { serverName });
-      this.agentEventBus.emit("dexto:stateChanged", {
+      this.agentEventBus.emit("mcp:server-removed", { serverName });
+      this.agentEventBus.emit("state:changed", {
         field: "mcpServers",
         oldValue: "removed",
         newValue: void 0
         // sessionId omitted - MCP servers are global
       });
-      logger.info(`MCP server '${serverName}' removed successfully`);
+      this.logger.info(`MCP server '${serverName}' removed successfully`);
     } else {
-      logger.warn(`MCP server '${serverName}' not found for removal`);
+      this.logger.warn(`MCP server '${serverName}' not found for removal`);
     }
   }
   // ============= SESSION MANAGEMENT =============
@@ -113,7 +118,7 @@ class AgentStateManager {
    */
   setSessionOverride(sessionId, override) {
     this.sessionOverrides.set(sessionId, override);
-    this.agentEventBus.emit("dexto:sessionOverrideSet", {
+    this.agentEventBus.emit("session:override-set", {
       sessionId,
       override: structuredClone(override)
     });
@@ -131,8 +136,8 @@ class AgentStateManager {
     const hadOverride = this.sessionOverrides.has(sessionId);
     this.sessionOverrides.delete(sessionId);
     if (hadOverride) {
-      this.agentEventBus.emit("dexto:sessionOverrideCleared", { sessionId });
-      logger.info("Session override cleared", { sessionId });
+      this.agentEventBus.emit("session:override-cleared", { sessionId });
+      this.logger.info("Session override cleared", { sessionId });
     }
   }
   /**
@@ -142,10 +147,10 @@ class AgentStateManager {
     const sessionIds = Array.from(this.sessionOverrides.keys());
     this.sessionOverrides.clear();
     sessionIds.forEach((sessionId) => {
-      this.agentEventBus.emit("dexto:sessionOverrideCleared", { sessionId });
+      this.agentEventBus.emit("session:override-cleared", { sessionId });
     });
     if (sessionIds.length > 0) {
-      logger.info("All session overrides cleared", { clearedSessions: sessionIds });
+      this.logger.info("All session overrides cleared", { clearedSessions: sessionIds });
     }
   }
   // ============= CONFIG EXPORT =============
@@ -160,10 +165,10 @@ class AgentStateManager {
       systemPrompt: this.runtimeConfig.systemPrompt,
       mcpServers: structuredClone(this.runtimeConfig.mcpServers)
     };
-    this.agentEventBus.emit("dexto:stateExported", {
+    this.agentEventBus.emit("state:exported", {
       config: exportedConfig
     });
-    logger.info("Runtime state exported as config", {
+    this.logger.info("Runtime state exported as config", {
       exportedConfig
     });
     return exportedConfig;
@@ -174,8 +179,8 @@ class AgentStateManager {
   resetToBaseline() {
     this.runtimeConfig = structuredClone(this.baselineConfig);
     this.clearAllSessionOverrides();
-    this.agentEventBus.emit("dexto:stateReset", { toConfig: this.baselineConfig });
-    logger.info("Runtime state reset to baseline config");
+    this.agentEventBus.emit("state:reset", { toConfig: this.baselineConfig });
+    this.logger.info("Runtime state reset to baseline config");
   }
   // ============= CONVENIENCE GETTERS FOR USED FUNCTIONALITY =============
   /**