@dexto/core 1.1.4 → 1.1.6

package/dist/agent/registry/types.cjs

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+__export(types_exports, {
+  AgentRegistryEntrySchema: () => AgentRegistryEntrySchema,
+  RegistrySchema: () => RegistrySchema
+});
+module.exports = __toCommonJS(types_exports);
+var import_zod = require("zod");
+const AgentRegistryEntrySchema = import_zod.z.object({
+  description: import_zod.z.string(),
+  author: import_zod.z.string(),
+  tags: import_zod.z.array(import_zod.z.string()),
+  source: import_zod.z.string(),
+  main: import_zod.z.string().optional()
+}).strict();
+const RegistrySchema = import_zod.z.object({
+  version: import_zod.z.string(),
+  agents: import_zod.z.record(import_zod.z.string(), AgentRegistryEntrySchema)
+}).strict();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentRegistryEntrySchema,
+  RegistrySchema
+});

package/dist/agent/registry/types.d.cts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+
+/**
+ * Schema for agent data in registry JSON
+ */
+declare const AgentRegistryEntrySchema: z.ZodObject<{
+    description: z.ZodString;
+    author: z.ZodString;
+    tags: z.ZodArray<z.ZodString, "many">;
+    source: z.ZodString;
+    main: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    description: string;
+    source: string;
+    tags: string[];
+    author: string;
+    main?: string | undefined;
+}, {
+    description: string;
+    source: string;
+    tags: string[];
+    author: string;
+    main?: string | undefined;
+}>;
+type AgentRegistryEntry = z.output<typeof AgentRegistryEntrySchema>;
+/**
+ * Schema for complete registry JSON
+ */
+declare const RegistrySchema: z.ZodObject<{
+    version: z.ZodString;
+    agents: z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodString;
+        author: z.ZodString;
+        tags: z.ZodArray<z.ZodString, "many">;
+        source: z.ZodString;
+        main: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        description: string;
+        source: string;
+        tags: string[];
+        author: string;
+        main?: string | undefined;
+    }, {
+        description: string;
+        source: string;
+        tags: string[];
+        author: string;
+        main?: string | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    version: string;
+    agents: Record<string, {
+        description: string;
+        source: string;
+        tags: string[];
+        author: string;
+        main?: string | undefined;
+    }>;
+}, {
+    version: string;
+    agents: Record<string, {
+        description: string;
+        source: string;
+        tags: string[];
+        author: string;
+        main?: string | undefined;
+    }>;
+}>;
+type Registry = z.output<typeof RegistrySchema>;
+/**
+ * Agent registry interface
+ */
+interface AgentRegistry {
+    /**
+     * Returns true if the registry contains an agent with the provided name
+     */
+    hasAgent(name: string): boolean;
+    /**
+     * Returns a map of available agent names to their registry entries
+     */
+    getAvailableAgents(): Record<string, AgentRegistryEntry>;
+    /**
+     * Installs an agent from the registry
+     */
+    installAgent(agentName: string, injectPreferences?: boolean): Promise<string>;
+    /**
+     * Uninstalls an agent
+     */
+    uninstallAgent(agentName: string, force?: boolean): Promise<void>;
+    /**
+     * Returns list of currently installed agents
+     */
+    getInstalledAgents(): Promise<string[]>;
+    /**
+     * Resolves and installs/copies the agent; returns the installed path (or main file)
+     */
+    resolveAgent(nameOrPath: string, autoInstall?: boolean, injectPreferences?: boolean): Promise<string>;
+}
+
+export { type AgentRegistry, type AgentRegistryEntry, AgentRegistryEntrySchema, type Registry, RegistrySchema };

package/dist/agent/registry/types.d.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+
+/**
+ * Schema for agent data in registry JSON
+ */
+declare const AgentRegistryEntrySchema: z.ZodObject<{
+    description: z.ZodString;
+    author: z.ZodString;
+    tags: z.ZodArray<z.ZodString, "many">;
+    source: z.ZodString;
+    main: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    description: string;
+    source: string;
+    tags: string[];
+    author: string;
+    main?: string | undefined;
+}, {
+    description: string;
+    source: string;
+    tags: string[];
+    author: string;
+    main?: string | undefined;
+}>;
+type AgentRegistryEntry = z.output<typeof AgentRegistryEntrySchema>;
+/**
+ * Schema for complete registry JSON
+ */
+declare const RegistrySchema: z.ZodObject<{
+    version: z.ZodString;
+    agents: z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodString;
+        author: z.ZodString;
+        tags: z.ZodArray<z.ZodString, "many">;
+        source: z.ZodString;
+        main: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        description: string;
+        source: string;
+        tags: string[];
+        author: string;
+        main?: string | undefined;
+    }, {
+        description: string;
+        source: string;
+        tags: string[];
+        author: string;
+        main?: string | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    version: string;
+    agents: Record<string, {
+        description: string;
+        source: string;
+        tags: string[];
+        author: string;
+        main?: string | undefined;
+    }>;
+}, {
+    version: string;
+    agents: Record<string, {
+        description: string;
+        source: string;
+        tags: string[];
+        author: string;
+        main?: string | undefined;
+    }>;
+}>;
+type Registry = z.output<typeof RegistrySchema>;
+/**
+ * Agent registry interface
+ */
+interface AgentRegistry {
+    /**
+     * Returns true if the registry contains an agent with the provided name
+     */
+    hasAgent(name: string): boolean;
+    /**
+     * Returns a map of available agent names to their registry entries
+     */
+    getAvailableAgents(): Record<string, AgentRegistryEntry>;
+    /**
+     * Installs an agent from the registry
+     */
+    installAgent(agentName: string, injectPreferences?: boolean): Promise<string>;
+    /**
+     * Uninstalls an agent
+     */
+    uninstallAgent(agentName: string, force?: boolean): Promise<void>;
+    /**
+     * Returns list of currently installed agents
+     */
+    getInstalledAgents(): Promise<string[]>;
+    /**
+     * Resolves and installs/copies the agent; returns the installed path (or main file)
+     */
+    resolveAgent(nameOrPath: string, autoInstall?: boolean, injectPreferences?: boolean): Promise<string>;
+}
+
+export { type AgentRegistry, type AgentRegistryEntry, AgentRegistryEntrySchema, type Registry, RegistrySchema };

package/dist/agent/registry/types.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+const AgentRegistryEntrySchema = z.object({
+  description: z.string(),
+  author: z.string(),
+  tags: z.array(z.string()),
+  source: z.string(),
+  main: z.string().optional()
+}).strict();
+const RegistrySchema = z.object({
+  version: z.string(),
+  agents: z.record(z.string(), AgentRegistryEntrySchema)
+}).strict();
+export {
+  AgentRegistryEntrySchema,
+  RegistrySchema
+};

package/dist/agent/schemas.cjs

@@ -0,0 +1,113 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schemas_exports = {};
+__export(schemas_exports, {
+  AgentCardSchema: () => AgentCardSchema,
+  AgentConfigSchema: () => AgentConfigSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_schemas = require("../llm/schemas.cjs");
+var import_schemas2 = require("../mcp/schemas.cjs");
+var import_schemas3 = require("../session/schemas.cjs");
+var import_schemas4 = require("../storage/schemas.cjs");
+var import_schemas5 = require("../systemPrompt/schemas.cjs");
+var import_schemas6 = require("../tools/schemas.cjs");
+var import_zod = require("zod");
+const AgentCardSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  // No default, must be provided by context
+  description: import_zod.z.string().default(
+    "Dexto is an AI assistant capable of chat and task delegation, accessible via multiple protocols."
+  ),
+  url: import_zod.z.string().url(),
+  // No default, must be provided by context
+  provider: import_zod.z.object({
+    organization: import_zod.z.string(),
+    url: import_zod.z.string().url()
+  }).optional(),
+  // Remains optional, undefined if not provided
+  version: import_zod.z.string(),
+  // No default, must be provided by context
+  documentationUrl: import_zod.z.string().url().optional(),
+  // Remains optional, undefined if not provided
+  capabilities: import_zod.z.object({
+    streaming: import_zod.z.boolean().optional().default(true),
+    pushNotifications: import_zod.z.boolean().optional(),
+    // Default is context-dependent (webSubscriber)
+    stateTransitionHistory: import_zod.z.boolean().optional().default(false)
+  }).strict().default({}),
+  // Add default for the capabilities object itself
+  authentication: import_zod.z.object({
+    schemes: import_zod.z.array(import_zod.z.string()).default([]),
+    credentials: import_zod.z.string().optional()
+    // Remains optional
+  }).strict().default({}),
+  // Add default for the authentication object itself
+  defaultInputModes: import_zod.z.array(import_zod.z.string()).default(["application/json", "text/plain"]),
+  defaultOutputModes: import_zod.z.array(import_zod.z.string()).default(["application/json", "text/event-stream", "text/plain"]),
+  skills: import_zod.z.array(
+    import_zod.z.object({
+      id: import_zod.z.string(),
+      name: import_zod.z.string(),
+      description: import_zod.z.string(),
+      tags: import_zod.z.array(import_zod.z.string()),
+      examples: import_zod.z.array(import_zod.z.string()).optional(),
+      inputModes: import_zod.z.array(import_zod.z.string()).optional().default(["text/plain"]),
+      outputModes: import_zod.z.array(import_zod.z.string()).optional().default(["text/plain"])
+    })
+  ).default([
+    {
+      id: "chat_with_agent",
+      name: "chat_with_agent",
+      description: "Allows you to chat with an AI agent. Send a message to interact.",
+      tags: ["chat", "AI", "assistant", "mcp", "natural language"],
+      examples: [
+        `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
+    }
+  ])
+}).strict();
+const AgentConfigSchema = import_zod.z.object({
+  agentCard: AgentCardSchema.describe("Configuration for the agent card").optional(),
+  greeting: import_zod.z.string().max(500).optional().describe("Default greeting text to show when a chat starts (for UI consumption)"),
+  systemPrompt: import_schemas5.SystemPromptConfigSchema.describe(
+    "System prompt: string shorthand or structured config"
+  ),
+  mcpServers: import_schemas2.ServerConfigsSchema.default({}).describe(
+    "Configurations for MCP (Model Context Protocol) servers used by the agent"
+  ),
+  internalTools: import_schemas6.InternalToolsSchema,
+  llm: import_schemas.LLMConfigSchema.describe("Core LLM configuration for the agent"),
+  // Storage configuration
+  storage: import_schemas4.StorageSchema.default({
+    cache: { type: "in-memory" },
+    database: { type: "in-memory" }
+  }).describe("Storage configuration for the agent using cache and database backends"),
+  sessions: import_schemas3.SessionConfigSchema.default({}).describe("Session management configuration"),
+  toolConfirmation: import_schemas6.ToolConfirmationConfigSchema.default({}).describe(
+    "Tool confirmation and approval configuration"
+  )
+}).strict().describe("Main configuration for an agent, including its LLM and server connections").brand();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentCardSchema,
+  AgentConfigSchema
+});