@chozzz/vargos 2.0.5 → 2.0.7

package/dist/services/config/schemas/mcp.js

@@ -0,0 +1,39 @@
+/**
+ * MCP (Model Context Protocol) configuration schemas
+ *
+ * Two patterns:
+ * 1. config.mcp — edge/mcp service exposes bus events as MCP tools to external clients
+ * 2. config.mcpServers — mcp-client service imports external MCP servers as bus events
+ */
+import { z } from 'zod';
+// ─── MCP edge (HTTP bridge) ──────────────────────────────────────────────────
+// Used by edge/mcp service to expose vargos tools to external MCP clients
+export const McpClientConfigSchema = z.object({
+    bearerToken: z.string().optional(),
+    host: z.string().optional(),
+    port: z.number().int().min(1).max(65535).optional(),
+    endpoint: z.string().optional(),
+    transport: z.enum(['http', 'stdio']).optional(),
+});
+// ─── MCP server connections ──────────────────────────────────────────────────
+// Used by mcp-client service to load external MCP servers
+//
+// Flexible schema supporting stdio transport.
+// Minimal validation — allows any extra fields for extensibility.
+//
+// Example configs:
+//
+// Stdio (uses command + optional args/env):
+// {
+//   "command": "uvx",
+//   "args": ["mcp-atlassian"],
+//   "env": { "JIRA_URL": "..." },
+//   "enabled": true
+// }
+//
+// Stdio shorthand:
+// {
+//   "command": "node /path/to/server.js"
+// }
+export const McpServerConfigSchema = z.record(z.string(), z.unknown()).describe('MCP server config — command/args/env for stdio transport');
+//# sourceMappingURL=mcp.js.map

package/dist/services/config/schemas/mcp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.js","sourceRoot":"","sources":["../../../../services/config/schemas/mcp.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,gFAAgF;AAChF,0EAA0E;AAE1E,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAClC,IAAI,EAAS,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAClC,IAAI,EAAS,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE;IAC1D,QAAQ,EAAK,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAClC,SAAS,EAAI,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,QAAQ,EAAE;CAClD,CAAC,CAAC;AAIH,gFAAgF;AAChF,0DAA0D;AAC1D,EAAE;AACF,8CAA8C;AAC9C,kEAAkE;AAClE,EAAE;AACF,mBAAmB;AACnB,EAAE;AACF,4CAA4C;AAC5C,IAAI;AACJ,sBAAsB;AACtB,+BAA+B;AAC/B,kCAAkC;AAClC,oBAAoB;AACpB,IAAI;AACJ,EAAE;AACF,mBAAmB;AACnB,IAAI;AACJ,yCAAyC;AACzC,IAAI;AAEJ,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,CAC7E,0DAA0D,CAC3D,CAAC"}

package/dist/services/config/schemas/primitives.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Primitive types and enums shared across config schemas
+ */
+import { z } from 'zod';
+export type Json = string | number | boolean | null | Json[] | {
+    [k: string]: Json;
+};
+export declare const JsonSchema: z.ZodType<Json>;
+export declare const ThinkingLevelSchema: z.ZodEnum<["off", "minimal", "low", "medium", "high", "xhigh"]>;
+export type ThinkingLevel = z.infer<typeof ThinkingLevelSchema>;
+export declare const ChannelTypeSchema: z.ZodEnum<["telegram", "whatsapp"]>;
+export type ChannelType = z.infer<typeof ChannelTypeSchema>;
+//# sourceMappingURL=primitives.d.ts.map

package/dist/services/config/schemas/primitives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.d.ts","sourceRoot":"","sources":["../../../../services/config/schemas/primitives.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,IAAI,EAAE,GAAG;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAGrF,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAStC,CAAC;AAIF,eAAO,MAAM,mBAAmB,iEAA+D,CAAC;AAChG,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,eAAO,MAAM,iBAAiB,qCAAmC,CAAC;AAClE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/services/config/schemas/primitives.js

@@ -0,0 +1,17 @@
+/**
+ * Primitive types and enums shared across config schemas
+ */
+import { z } from 'zod';
+// z.lazy is required for the recursive JSON type
+export const JsonSchema = z.lazy(() => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(JsonSchema),
+    z.record(z.string(), JsonSchema),
+]));
+// ─── Common enums ─────────────────────────────────────────────────────────────
+export const ThinkingLevelSchema = z.enum(['off', 'minimal', 'low', 'medium', 'high', 'xhigh']);
+export const ChannelTypeSchema = z.enum(['telegram', 'whatsapp']);
+//# sourceMappingURL=primitives.js.map

package/dist/services/config/schemas/primitives.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.js","sourceRoot":"","sources":["../../../../services/config/schemas/primitives.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,iDAAiD;AACjD,MAAM,CAAC,MAAM,UAAU,GAAoB,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CACrD,CAAC,CAAC,KAAK,CAAC;IACN,CAAC,CAAC,MAAM,EAAE;IACV,CAAC,CAAC,MAAM,EAAE;IACV,CAAC,CAAC,OAAO,EAAE;IACX,CAAC,CAAC,IAAI,EAAE;IACR,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC;IACnB,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,UAAU,CAAC;CACjC,CAAC,CACH,CAAC;AAEF,iFAAiF;AAEjF,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAGhG,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC"}

package/dist/services/config/schemas/providers.d.ts

@@ -0,0 +1,335 @@
+/**
+ * Provider configuration schemas (from ~/.vargos/agent/models.json)
+ *
+ * Providers include baseUrl, API type, and registry of available models with cost/capability info.
+ */
+import { z } from 'zod';
+export declare const ProviderConfigSchema: z.ZodObject<{
+    baseUrl: z.ZodString;
+    api: z.ZodDefault<z.ZodString>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    models: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        reasoning: z.ZodOptional<z.ZodBoolean>;
+        input: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        cost: z.ZodOptional<z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodOptional<z.ZodNumber>;
+            cacheWrite: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        }, {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        }>>;
+        contextWindow: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        reasoning?: boolean | undefined;
+        input?: string[] | undefined;
+        cost?: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        } | undefined;
+        contextWindow?: number | undefined;
+        maxTokens?: number | undefined;
+    }, {
+        id: string;
+        name: string;
+        reasoning?: boolean | undefined;
+        input?: string[] | undefined;
+        cost?: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        } | undefined;
+        contextWindow?: number | undefined;
+        maxTokens?: number | undefined;
+    }>, "many">>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    baseUrl: z.ZodString;
+    api: z.ZodDefault<z.ZodString>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    models: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        reasoning: z.ZodOptional<z.ZodBoolean>;
+        input: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        cost: z.ZodOptional<z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodOptional<z.ZodNumber>;
+            cacheWrite: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        }, {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        }>>;
+        contextWindow: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        reasoning?: boolean | undefined;
+        input?: string[] | undefined;
+        cost?: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        } | undefined;
+        contextWindow?: number | undefined;
+        maxTokens?: number | undefined;
+    }, {
+        id: string;
+        name: string;
+        reasoning?: boolean | undefined;
+        input?: string[] | undefined;
+        cost?: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        } | undefined;
+        contextWindow?: number | undefined;
+        maxTokens?: number | undefined;
+    }>, "many">>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    baseUrl: z.ZodString;
+    api: z.ZodDefault<z.ZodString>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    models: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        reasoning: z.ZodOptional<z.ZodBoolean>;
+        input: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        cost: z.ZodOptional<z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodOptional<z.ZodNumber>;
+            cacheWrite: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        }, {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        }>>;
+        contextWindow: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        reasoning?: boolean | undefined;
+        input?: string[] | undefined;
+        cost?: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        } | undefined;
+        contextWindow?: number | undefined;
+        maxTokens?: number | undefined;
+    }, {
+        id: string;
+        name: string;
+        reasoning?: boolean | undefined;
+        input?: string[] | undefined;
+        cost?: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        } | undefined;
+        contextWindow?: number | undefined;
+        maxTokens?: number | undefined;
+    }>, "many">>;
+}, z.ZodTypeAny, "passthrough">>;
+export declare const ProvidersSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    baseUrl: z.ZodString;
+    api: z.ZodDefault<z.ZodString>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    models: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        reasoning: z.ZodOptional<z.ZodBoolean>;
+        input: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        cost: z.ZodOptional<z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodOptional<z.ZodNumber>;
+            cacheWrite: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        }, {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        }>>;
+        contextWindow: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        reasoning?: boolean | undefined;
+        input?: string[] | undefined;
+        cost?: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        } | undefined;
+        contextWindow?: number | undefined;
+        maxTokens?: number | undefined;
+    }, {
+        id: string;
+        name: string;
+        reasoning?: boolean | undefined;
+        input?: string[] | undefined;
+        cost?: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        } | undefined;
+        contextWindow?: number | undefined;
+        maxTokens?: number | undefined;
+    }>, "many">>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    baseUrl: z.ZodString;
+    api: z.ZodDefault<z.ZodString>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    models: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        reasoning: z.ZodOptional<z.ZodBoolean>;
+        input: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        cost: z.ZodOptional<z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodOptional<z.ZodNumber>;
+            cacheWrite: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        }, {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        }>>;
+        contextWindow: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        reasoning?: boolean | undefined;
+        input?: string[] | undefined;
+        cost?: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        } | undefined;
+        contextWindow?: number | undefined;
+        maxTokens?: number | undefined;
+    }, {
+        id: string;
+        name: string;
+        reasoning?: boolean | undefined;
+        input?: string[] | undefined;
+        cost?: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        } | undefined;
+        contextWindow?: number | undefined;
+        maxTokens?: number | undefined;
+    }>, "many">>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    baseUrl: z.ZodString;
+    api: z.ZodDefault<z.ZodString>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    models: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        reasoning: z.ZodOptional<z.ZodBoolean>;
+        input: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        cost: z.ZodOptional<z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodOptional<z.ZodNumber>;
+            cacheWrite: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        }, {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        }>>;
+        contextWindow: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        reasoning?: boolean | undefined;
+        input?: string[] | undefined;
+        cost?: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        } | undefined;
+        contextWindow?: number | undefined;
+        maxTokens?: number | undefined;
+    }, {
+        id: string;
+        name: string;
+        reasoning?: boolean | undefined;
+        input?: string[] | undefined;
+        cost?: {
+            input: number;
+            output: number;
+            cacheRead?: number | undefined;
+            cacheWrite?: number | undefined;
+        } | undefined;
+        contextWindow?: number | undefined;
+        maxTokens?: number | undefined;
+    }>, "many">>;
+}, z.ZodTypeAny, "passthrough">>>;
+export type ProviderConfig = z.infer<typeof ProviderConfigSchema>;
+export type Providers = z.infer<typeof ProvidersSchema>;
+//# sourceMappingURL=providers.d.ts.map

package/dist/services/config/schemas/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../../../services/config/schemas/providers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAkBjB,CAAC;AAEjB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAA6C,CAAC;AAE1E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/services/config/schemas/providers.js

@@ -0,0 +1,27 @@
+/**
+ * Provider configuration schemas (from ~/.vargos/agent/models.json)
+ *
+ * Providers include baseUrl, API type, and registry of available models with cost/capability info.
+ */
+import { z } from 'zod';
+export const ProviderConfigSchema = z.object({
+    baseUrl: z.string(),
+    api: z.string().default('openai-completions').describe('API type (default: openai-completions)'),
+    apiKey: z.string().optional().describe('API key (optional, required for custom providers)'),
+    models: z.array(z.object({
+        id: z.string(),
+        name: z.string(),
+        reasoning: z.boolean().optional(),
+        input: z.array(z.string()).optional(),
+        cost: z.object({
+            input: z.number(),
+            output: z.number(),
+            cacheRead: z.number().optional(),
+            cacheWrite: z.number().optional(),
+        }).optional(),
+        contextWindow: z.number().optional(),
+        maxTokens: z.number().optional(),
+    })).optional(),
+}).passthrough();
+export const ProvidersSchema = z.record(z.string(), ProviderConfigSchema);
+//# sourceMappingURL=providers.js.map

package/dist/services/config/schemas/providers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.js","sourceRoot":"","sources":["../../../../services/config/schemas/providers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC,QAAQ,CAAC,wCAAwC,CAAC;IAChG,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,mDAAmD,CAAC;IAC3F,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;QACvB,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;QACd,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;QAChB,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;QACjC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;QACrC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC;YACb,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;YACjB,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;YAClB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;YAChC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;SAClC,CAAC,CAAC,QAAQ,EAAE;QACb,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QACpC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KACjC,CAAC,CAAC,CAAC,QAAQ,EAAE;CACf,CAAC,CAAC,WAAW,EAAE,CAAC;AAEjB,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,oBAAoB,CAAC,CAAC"}

package/dist/services/config/schemas/storage.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Storage configuration schemas (memory backend hint)
+ */
+import { z } from 'zod';
+export declare const StorageConfigSchema: z.ZodObject<{
+    type: z.ZodDefault<z.ZodEnum<["sqlite", "postgres"]>>;
+    url: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "sqlite" | "postgres";
+    url?: string | undefined;
+}, {
+    type?: "sqlite" | "postgres" | undefined;
+    url?: string | undefined;
+}>;
+export type StorageConfig = z.infer<typeof StorageConfigSchema>;
+//# sourceMappingURL=storage.d.ts.map

package/dist/services/config/schemas/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../../services/config/schemas/storage.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,mBAAmB;;;;;;;;;EAG9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/services/config/schemas/storage.js

@@ -0,0 +1,9 @@
+/**
+ * Storage configuration schemas (memory backend hint)
+ */
+import { z } from 'zod';
+export const StorageConfigSchema = z.object({
+    type: z.enum(['sqlite', 'postgres']).default('sqlite'),
+    url: z.string().optional(),
+});
+//# sourceMappingURL=storage.js.map

package/dist/services/config/schemas/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../../../services/config/schemas/storage.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;IACtD,GAAG,EAAG,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC5B,CAAC,CAAC"}

package/dist/services/config/schemas/webhooks.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Webhook configuration schemas
+ */
+import { z } from 'zod';
+export declare const WebhookEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    token: z.ZodString;
+    transform: z.ZodOptional<z.ZodString>;
+    notify: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    token: string;
+    notify?: string[] | undefined;
+    transform?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    token: string;
+    notify?: string[] | undefined;
+    transform?: string | undefined;
+}>;
+export type WebhookEntry = z.infer<typeof WebhookEntrySchema>;
+//# sourceMappingURL=webhooks.d.ts.map

package/dist/services/config/schemas/webhooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhooks.d.ts","sourceRoot":"","sources":["../../../../services/config/schemas/webhooks.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;EAM7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/services/config/schemas/webhooks.js

@@ -0,0 +1,12 @@
+/**
+ * Webhook configuration schemas
+ */
+import { z } from 'zod';
+export const WebhookEntrySchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    token: z.string(),
+    transform: z.string().optional(), // path to JS/TS transform file
+    notify: z.array(z.string()).optional(),
+});
+//# sourceMappingURL=webhooks.js.map

package/dist/services/config/schemas/webhooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhooks.js","sourceRoot":"","sources":["../../../../services/config/schemas/webhooks.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,EAAE,EAAS,CAAC,CAAC,MAAM,EAAE;IACrB,IAAI,EAAO,CAAC,CAAC,MAAM,EAAE;IACrB,KAAK,EAAM,CAAC,CAAC,MAAM,EAAE;IACrB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAG,+BAA+B;IAClE,MAAM,EAAK,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;CAC1C,CAAC,CAAC"}

package/dist/services/cron/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Cron service — schedules and fires periodic tasks.
+ *
+ * Callable: cron.search, cron.add, cron.remove, cron.update, cron.run
+ *
+ * Concurrency: one active run per task (via activeTasks set).
+ * Lock released on agent.onCompleted for cron sessions.
+ *
+ * Delivery: after each run, sends result to task's notify targets.
+ * Heartbeat OK responses (HEARTBEAT_OK) are pruned silently.
+ * Subagent deferral: if subagents are still running, the agent runtime may
+ * defer delivery until the parent run completes.
+ */
+import type { Bus } from '../../gateway/bus.js';
+import type { EventMap } from '../../gateway/events.js';
+import type { AppConfig, CronAddParams, CronUpdateParams } from '../../services/config/index.js';
+export declare class CronService {
+    private readonly bus;
+    private readonly config;
+    private jobs;
+    private ephemeralIds;
+    private activeTasks;
+    private beforeFireHooks;
+    private unsubscribeCompleted?;
+    private readonly cronDir;
+    constructor(bus: Bus, config: AppConfig, cronDir?: string);
+    start(): Promise<void>;
+    stop(): void;
+    search(params: EventMap['cron.search']['params']): Promise<EventMap['cron.search']['result']>;
+    add(params: CronAddParams): Promise<void>;
+    remove(params: EventMap['cron.remove']['params']): Promise<void>;
+    update(params: CronUpdateParams): Promise<void>;
+    run(params: EventMap['cron.run']['params']): Promise<void>;
+    private addJob;
+    private startAll;
+    private stopAll;
+    private fire;
+    private onAgentCompleted;
+    private executeTask;
+    private parseMarkdownTask;
+    private serializeMarkdownTask;
+    private loadTasksFromDisk;
+    private writeTaskToDisk;
+    private deleteTaskFromDisk;
+    private registerHeartbeat;
+}
+export declare function boot(bus: Bus): Promise<{
+    stop(): void;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/services/cron/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../services/cron/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAOH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAY,aAAa,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAkB3G,qBAAa,WAAW;IASpB,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM;IATzB,OAAO,CAAC,IAAI,CAAuD;IACnE,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,eAAe,CAA6C;IACpE,OAAO,CAAC,oBAAoB,CAAC,CAAa;IAC1C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAGd,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,SAAS,EAClC,OAAO,CAAC,EAAE,MAAM;IAKZ,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAoB5B,IAAI,IAAI,IAAI;IAWN,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,QAAQ,CAAC,CAAC;IAqB7F,GAAG,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAqBzC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IA8BhE,MAAM,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAsC/C,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAWhE,OAAO,CAAC,MAAM;IAMd,OAAO,CAAC,QAAQ;IAchB,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,IAAI;IAgCZ,OAAO,CAAC,gBAAgB;YAYV,WAAW;IAoCzB,OAAO,CAAC,iBAAiB;IAMzB,OAAO,CAAC,qBAAqB;YAKf,iBAAiB;YAiEjB,eAAe;YAiCf,kBAAkB;IAchC,OAAO,CAAC,iBAAiB;CA6B1B;AAID,wBAAsB,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC;IAAE,IAAI,IAAI,IAAI,CAAA;CAAE,CAAC,CAO9D"}