skedyul 1.2.41 → 1.2.43

package/dist/memory/index.d.ts

@@ -0,0 +1,4 @@
+export { MemoryEntryTypeSchema, MemoryEntrySchema, WorkingMemoryConfigSchema, SemanticMemoryConfigSchema, ExternalMemoryConfigSchema, MemoryConfigSchema, MemoryScopeSchema, MemoryQueryOptionsSchema, ConversationSummarySchema, AgentObservationSchema, ExternalDataCacheSchema, } from './types';
+export type { MemoryEntryType, MemoryEntry, WorkingMemoryConfig, SemanticMemoryConfig, ExternalMemoryConfig, MemoryConfig, MemoryScope, MemoryQueryOptions, ConversationSummary, AgentObservation, ExternalDataCache, } from './types';
+export { MemoryService, InMemoryStore, createInMemoryService, } from './service';
+export type { MemoryStore } from './service';

package/dist/memory/service.d.ts

@@ -0,0 +1,78 @@
+import type { MemoryScope, MemoryEntry, MemoryEntryType, MemoryQueryOptions, ConversationSummary, AgentObservation, ExternalDataCache, WorkingMemoryConfig } from './types';
+/**
+ * Memory store interface - implemented by database or in-memory store
+ */
+export interface MemoryStore {
+    get(scope: MemoryScope, key: string): Promise<MemoryEntry | null>;
+    set(scope: MemoryScope, key: string, value: unknown, options?: {
+        type?: MemoryEntryType;
+        expiresAt?: Date;
+        metadata?: Record<string, unknown>;
+    }): Promise<MemoryEntry>;
+    delete(scope: MemoryScope, key: string): Promise<void>;
+    query(scope: MemoryScope, options?: Partial<MemoryQueryOptions>): Promise<MemoryEntry[]>;
+    clear(scope: MemoryScope, type?: MemoryEntryType): Promise<void>;
+}
+/**
+ * In-memory store for testing and development
+ */
+export declare class InMemoryStore implements MemoryStore {
+    private store;
+    private buildKey;
+    get(scope: MemoryScope, key: string): Promise<MemoryEntry | null>;
+    set(scope: MemoryScope, key: string, value: unknown, options?: {
+        type?: MemoryEntryType;
+        expiresAt?: Date;
+        metadata?: Record<string, unknown>;
+    }): Promise<MemoryEntry>;
+    delete(scope: MemoryScope, key: string): Promise<void>;
+    query(scope: MemoryScope, options?: Partial<MemoryQueryOptions>): Promise<MemoryEntry[]>;
+    clear(scope: MemoryScope, type?: MemoryEntryType): Promise<void>;
+}
+/**
+ * Memory service for agent memory management
+ */
+export declare class MemoryService {
+    private store;
+    constructor(store: MemoryStore);
+    /**
+     * Get working memory for a thread/participant
+     */
+    getWorkingMemory(scope: MemoryScope): Promise<ConversationSummary | null>;
+    /**
+     * Update working memory with new conversation summary
+     */
+    updateWorkingMemory(scope: MemoryScope, summary: ConversationSummary, config?: WorkingMemoryConfig): Promise<void>;
+    /**
+     * Add an observation to memory
+     */
+    addObservation(scope: MemoryScope, observation: Omit<AgentObservation, 'createdAt'>): Promise<void>;
+    /**
+     * Get all observations for a scope
+     */
+    getObservations(scope: MemoryScope, limit?: number): Promise<AgentObservation[]>;
+    /**
+     * Cache external API data
+     */
+    cacheExternalData(scope: MemoryScope, source: string, data: unknown, options?: {
+        endpoint?: string;
+        ttl?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
+    /**
+     * Get cached external data
+     */
+    getExternalData(scope: MemoryScope, source: string): Promise<ExternalDataCache | null>;
+    /**
+     * Clear all external data cache
+     */
+    clearExternalCache(scope: MemoryScope): Promise<void>;
+    /**
+     * Build context string from memory for LLM prompt
+     */
+    buildMemoryContext(scope: MemoryScope): Promise<string>;
+}
+/**
+ * Create a memory service with in-memory store (for testing)
+ */
+export declare function createInMemoryService(): MemoryService;

package/dist/memory/types.d.ts

@@ -0,0 +1,169 @@
+import { z } from 'zod/v4';
+/**
+ * Memory entry types
+ */
+export declare const MemoryEntryTypeSchema: z.ZodEnum<{
+    EXTERNAL: "EXTERNAL";
+    WORKING: "WORKING";
+    OBSERVATION: "OBSERVATION";
+    SEMANTIC: "SEMANTIC";
+}>;
+export type MemoryEntryType = z.infer<typeof MemoryEntryTypeSchema>;
+/**
+ * Memory entry schema
+ */
+export declare const MemoryEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        EXTERNAL: "EXTERNAL";
+        WORKING: "WORKING";
+        OBSERVATION: "OBSERVATION";
+        SEMANTIC: "SEMANTIC";
+    }>;
+    key: z.ZodString;
+    value: z.ZodUnknown;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    expiresAt: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type MemoryEntry = z.infer<typeof MemoryEntrySchema>;
+/**
+ * Working memory configuration
+ */
+export declare const WorkingMemoryConfigSchema: z.ZodObject<{
+    strategy: z.ZodDefault<z.ZodEnum<{
+        full: "full";
+        rolling_summary: "rolling_summary";
+        sliding_window: "sliding_window";
+    }>>;
+    maxTokens: z.ZodDefault<z.ZodNumber>;
+    summarizeAt: z.ZodOptional<z.ZodNumber>;
+    ttl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type WorkingMemoryConfig = z.infer<typeof WorkingMemoryConfigSchema>;
+/**
+ * Semantic memory configuration
+ */
+export declare const SemanticMemoryConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    topK: z.ZodDefault<z.ZodNumber>;
+    scope: z.ZodDefault<z.ZodEnum<{
+        instance: "instance";
+        thread: "thread";
+        workspace: "workspace";
+    }>>;
+    minScore: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type SemanticMemoryConfig = z.infer<typeof SemanticMemoryConfigSchema>;
+/**
+ * External memory configuration
+ */
+export declare const ExternalMemoryConfigSchema: z.ZodObject<{
+    namespace: z.ZodString;
+    ttl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ExternalMemoryConfig = z.infer<typeof ExternalMemoryConfigSchema>;
+/**
+ * Full memory configuration
+ */
+export declare const MemoryConfigSchema: z.ZodObject<{
+    working: z.ZodOptional<z.ZodObject<{
+        strategy: z.ZodDefault<z.ZodEnum<{
+            full: "full";
+            rolling_summary: "rolling_summary";
+            sliding_window: "sliding_window";
+        }>>;
+        maxTokens: z.ZodDefault<z.ZodNumber>;
+        summarizeAt: z.ZodOptional<z.ZodNumber>;
+        ttl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    semantic: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        topK: z.ZodDefault<z.ZodNumber>;
+        scope: z.ZodDefault<z.ZodEnum<{
+            instance: "instance";
+            thread: "thread";
+            workspace: "workspace";
+        }>>;
+        minScore: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    external: z.ZodOptional<z.ZodObject<{
+        namespace: z.ZodString;
+        ttl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    persistent: z.ZodOptional<z.ZodObject<{
+        namespace: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MemoryConfig = z.infer<typeof MemoryConfigSchema>;
+/**
+ * Memory scope for queries
+ */
+export declare const MemoryScopeSchema: z.ZodObject<{
+    threadId: z.ZodOptional<z.ZodString>;
+    participantId: z.ZodOptional<z.ZodString>;
+    agentId: z.ZodOptional<z.ZodString>;
+    workplaceId: z.ZodOptional<z.ZodString>;
+    namespace: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type MemoryScope = z.infer<typeof MemoryScopeSchema>;
+/**
+ * Memory query options
+ */
+export declare const MemoryQueryOptionsSchema: z.ZodObject<{
+    types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        EXTERNAL: "EXTERNAL";
+        WORKING: "WORKING";
+        OBSERVATION: "OBSERVATION";
+        SEMANTIC: "SEMANTIC";
+    }>>>;
+    keys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    includeExpired: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type MemoryQueryOptions = z.infer<typeof MemoryQueryOptionsSchema>;
+/**
+ * Conversation summary for working memory
+ */
+export declare const ConversationSummarySchema: z.ZodObject<{
+    summary: z.ZodString;
+    keyPoints: z.ZodArray<z.ZodString>;
+    entities: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        relevance: z.ZodNumber;
+    }, z.core.$strip>>;
+    lastMessageId: z.ZodOptional<z.ZodString>;
+    messageCount: z.ZodNumber;
+    tokenCount: z.ZodNumber;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type ConversationSummary = z.infer<typeof ConversationSummarySchema>;
+/**
+ * Agent observation
+ */
+export declare const AgentObservationSchema: z.ZodObject<{
+    observation: z.ZodString;
+    confidence: z.ZodNumber;
+    source: z.ZodEnum<{
+        inference: "inference";
+        explicit: "explicit";
+        tool_result: "tool_result";
+    }>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type AgentObservation = z.infer<typeof AgentObservationSchema>;
+/**
+ * External data cache entry
+ */
+export declare const ExternalDataCacheSchema: z.ZodObject<{
+    source: z.ZodString;
+    endpoint: z.ZodOptional<z.ZodString>;
+    data: z.ZodUnknown;
+    fetchedAt: z.ZodString;
+    expiresAt: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type ExternalDataCache = z.infer<typeof ExternalDataCacheSchema>;

package/dist/schemas/agent-schema-v3.d.ts

@@ -0,0 +1,437 @@
+import { z } from 'zod/v4';
+/**
+ * Agent YAML v3 Schema
+ *
+ * This is the new agent schema that removes stages and uses skills instead.
+ * Agents are now first-class thread participants that subscribe to events
+ * and react autonomously using skills and tools.
+ */
+export declare const AGENT_SCHEMA_VERSION_V3 = "https://skedyul.com/schemas/agent/v3";
+/**
+ * Persona voice format configuration
+ */
+export declare const PersonaVoiceFormatV3Schema: z.ZodObject<{
+    maxChars: z.ZodOptional<z.ZodNumber>;
+    noEmojis: z.ZodOptional<z.ZodBoolean>;
+    noHyphens: z.ZodOptional<z.ZodBoolean>;
+    noBulletPoints: z.ZodOptional<z.ZodBoolean>;
+    maxQuestionsPerMessage: z.ZodOptional<z.ZodNumber>;
+    noSignOffs: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type PersonaVoiceFormatV3 = z.infer<typeof PersonaVoiceFormatV3Schema>;
+/**
+ * Persona voice configuration
+ */
+export declare const PersonaVoiceV3Schema: z.ZodObject<{
+    style: z.ZodString;
+    format: z.ZodOptional<z.ZodObject<{
+        maxChars: z.ZodOptional<z.ZodNumber>;
+        noEmojis: z.ZodOptional<z.ZodBoolean>;
+        noHyphens: z.ZodOptional<z.ZodBoolean>;
+        noBulletPoints: z.ZodOptional<z.ZodBoolean>;
+        maxQuestionsPerMessage: z.ZodOptional<z.ZodNumber>;
+        noSignOffs: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PersonaVoiceV3 = z.infer<typeof PersonaVoiceV3Schema>;
+/**
+ * Persona configuration for agent voice and formatting
+ */
+export declare const PersonaV3Schema: z.ZodObject<{
+    name: z.ZodString;
+    voice: z.ZodObject<{
+        style: z.ZodString;
+        format: z.ZodOptional<z.ZodObject<{
+            maxChars: z.ZodOptional<z.ZodNumber>;
+            noEmojis: z.ZodOptional<z.ZodBoolean>;
+            noHyphens: z.ZodOptional<z.ZodBoolean>;
+            noBulletPoints: z.ZodOptional<z.ZodBoolean>;
+            maxQuestionsPerMessage: z.ZodOptional<z.ZodNumber>;
+            noSignOffs: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PersonaV3 = z.infer<typeof PersonaV3Schema>;
+/**
+ * Tool approval configuration
+ */
+export declare const ToolApprovalConfigSchema: z.ZodObject<{
+    required: z.ZodOptional<z.ZodBoolean>;
+    requiredIf: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type ToolApprovalConfig = z.infer<typeof ToolApprovalConfigSchema>;
+/**
+ * Tool sandbox configuration for mock responses
+ */
+export declare const ToolSandboxConfigSchema: z.ZodObject<{
+    mock: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type ToolSandboxConfig = z.infer<typeof ToolSandboxConfigSchema>;
+/**
+ * Tool reference with optional approval and sandbox configuration
+ * @deprecated Root-level tools on agents are deprecated. Use skills to own tools.
+ * For always-available system tools, use bootstrapTools instead.
+ */
+export declare const ToolRefV3Schema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    tool: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    approval: z.ZodOptional<z.ZodObject<{
+        required: z.ZodOptional<z.ZodBoolean>;
+        requiredIf: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    sandbox: z.ZodOptional<z.ZodObject<{
+        mock: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>;
+    overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>]>;
+export type ToolRefV3 = z.infer<typeof ToolRefV3Schema>;
+/**
+ * Bootstrap tool reference - minimal config for always-available system tools
+ * These tools are available before any skill is loaded (e.g., system:skill:load)
+ */
+export declare const BootstrapToolRefSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    tool: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+export type BootstrapToolRef = z.infer<typeof BootstrapToolRefSchema>;
+/**
+ * Memory configuration for working memory
+ */
+export declare const WorkingMemoryConfigSchema: z.ZodObject<{
+    strategy: z.ZodOptional<z.ZodEnum<{
+        full: "full";
+        rolling_summary: "rolling_summary";
+        sliding_window: "sliding_window";
+    }>>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    summarizeAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type WorkingMemoryConfig = z.infer<typeof WorkingMemoryConfigSchema>;
+/**
+ * Memory configuration for external data
+ */
+export declare const ExternalMemoryConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    ttl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ExternalMemoryConfig = z.infer<typeof ExternalMemoryConfigSchema>;
+/**
+ * Memory configuration for semantic search
+ */
+export declare const SemanticMemoryConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    topK: z.ZodOptional<z.ZodNumber>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        instance: "instance";
+        thread: "thread";
+        workspace: "workspace";
+    }>>;
+}, z.core.$strip>;
+export type SemanticMemoryConfig = z.infer<typeof SemanticMemoryConfigSchema>;
+/**
+ * Full memory configuration
+ */
+export declare const MemoryConfigV3Schema: z.ZodObject<{
+    working: z.ZodOptional<z.ZodObject<{
+        strategy: z.ZodOptional<z.ZodEnum<{
+            full: "full";
+            rolling_summary: "rolling_summary";
+            sliding_window: "sliding_window";
+        }>>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        summarizeAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    persistent: z.ZodOptional<z.ZodObject<{
+        namespace: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    external: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        ttl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    semantic: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        topK: z.ZodOptional<z.ZodNumber>;
+        scope: z.ZodOptional<z.ZodEnum<{
+            instance: "instance";
+            thread: "thread";
+            workspace: "workspace";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MemoryConfigV3 = z.infer<typeof MemoryConfigV3Schema>;
+/**
+ * Policy configuration for response approval
+ */
+export declare const ResponsePolicySchema: z.ZodObject<{
+    requiresApproval: z.ZodOptional<z.ZodBoolean>;
+    requiresApprovalIf: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type ResponsePolicy = z.infer<typeof ResponsePolicySchema>;
+/**
+ * Full policies configuration
+ */
+export declare const PoliciesConfigV3Schema: z.ZodObject<{
+    response: z.ZodOptional<z.ZodObject<{
+        requiresApproval: z.ZodOptional<z.ZodBoolean>;
+        requiresApprovalIf: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    rules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type PoliciesConfigV3 = z.infer<typeof PoliciesConfigV3Schema>;
+/**
+ * Runtime configuration
+ */
+export declare const RuntimeConfigV3Schema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodOptional<z.ZodString>;
+    timezone: z.ZodOptional<z.ZodString>;
+    retry: z.ZodOptional<z.ZodObject<{
+        attempts: z.ZodOptional<z.ZodNumber>;
+        backoff: z.ZodOptional<z.ZodEnum<{
+            linear: "linear";
+            exponential: "exponential";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RuntimeConfigV3 = z.infer<typeof RuntimeConfigV3Schema>;
+/**
+ * Prompts configuration for agent-specific prompt injections.
+ * These prompts are injected during specific runtime phases.
+ */
+export declare const PromptsConfigV3Schema: z.ZodObject<{
+    recovery: z.ZodOptional<z.ZodString>;
+    followUp: z.ZodOptional<z.ZodString>;
+    skillDiscoveryWorkflow: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PromptsConfigV3 = z.infer<typeof PromptsConfigV3Schema>;
+/**
+ * Agent configuration (business-specific settings)
+ */
+export declare const AgentConfigV3Schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type AgentConfigV3 = z.infer<typeof AgentConfigV3Schema>;
+/**
+ * Full Agent YAML v3 Schema
+ *
+ * This schema removes stages and uses skills instead.
+ * Agents subscribe to events and react autonomously.
+ *
+ * Tool Ownership Model:
+ * - Skills own their tools (defined in skill files with full config)
+ * - Agents reference skills, not individual tools
+ * - bootstrapTools: Always-available system tools (e.g., system:skill:load)
+ * - tools: DEPRECATED - kept for backward compatibility only
+ */
+export declare const AgentYAMLV3Schema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    handle: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    persona: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        voice: z.ZodObject<{
+            style: z.ZodString;
+            format: z.ZodOptional<z.ZodObject<{
+                maxChars: z.ZodOptional<z.ZodNumber>;
+                noEmojis: z.ZodOptional<z.ZodBoolean>;
+                noHyphens: z.ZodOptional<z.ZodBoolean>;
+                noBulletPoints: z.ZodOptional<z.ZodBoolean>;
+                maxQuestionsPerMessage: z.ZodOptional<z.ZodNumber>;
+                noSignOffs: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        skill: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodNumber>;
+        versions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            version: z.ZodNumber;
+            weight: z.ZodNumber;
+        }, z.core.$strip>>>;
+        instructions: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>]>>>;
+    bootstrapTools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        tool: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        tool: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        approval: z.ZodOptional<z.ZodObject<{
+            required: z.ZodOptional<z.ZodBoolean>;
+            requiredIf: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        sandbox: z.ZodOptional<z.ZodObject<{
+            mock: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>;
+        overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>]>>>;
+    events: z.ZodOptional<z.ZodObject<{
+        subscribes: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+            "thread.message.received": "thread.message.received";
+            "thread.message.sent": "thread.message.sent";
+            "thread.participant.joined": "thread.participant.joined";
+            "thread.participant.left": "thread.participant.left";
+            "thread.participant.mentioned": "thread.participant.mentioned";
+            "thread.context.changed": "thread.context.changed";
+            "thread.status.changed": "thread.status.changed";
+            "thread.agent.delegated": "thread.agent.delegated";
+            "thread.agent.completed": "thread.agent.completed";
+            "thread.workflow.triggered": "thread.workflow.triggered";
+            "thread.workflow.completed": "thread.workflow.completed";
+            "thread.follow_up.due": "thread.follow_up.due";
+            "thread.reminder.due": "thread.reminder.due";
+        }>, z.ZodString]>>>;
+        condition: z.ZodOptional<z.ZodString>;
+        emits: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+            "thread.message.received": "thread.message.received";
+            "thread.message.sent": "thread.message.sent";
+            "thread.participant.joined": "thread.participant.joined";
+            "thread.participant.left": "thread.participant.left";
+            "thread.participant.mentioned": "thread.participant.mentioned";
+            "thread.context.changed": "thread.context.changed";
+            "thread.status.changed": "thread.status.changed";
+            "thread.agent.delegated": "thread.agent.delegated";
+            "thread.agent.completed": "thread.agent.completed";
+            "thread.workflow.triggered": "thread.workflow.triggered";
+            "thread.workflow.completed": "thread.workflow.completed";
+            "thread.follow_up.due": "thread.follow_up.due";
+            "thread.reminder.due": "thread.reminder.due";
+        }>, z.ZodString]>>>;
+        waits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            event: z.ZodUnion<readonly [z.ZodEnum<{
+                "thread.message.received": "thread.message.received";
+                "thread.message.sent": "thread.message.sent";
+                "thread.participant.joined": "thread.participant.joined";
+                "thread.participant.left": "thread.participant.left";
+                "thread.participant.mentioned": "thread.participant.mentioned";
+                "thread.context.changed": "thread.context.changed";
+                "thread.status.changed": "thread.status.changed";
+                "thread.agent.delegated": "thread.agent.delegated";
+                "thread.agent.completed": "thread.agent.completed";
+                "thread.workflow.triggered": "thread.workflow.triggered";
+                "thread.workflow.completed": "thread.workflow.completed";
+                "thread.follow_up.due": "thread.follow_up.due";
+                "thread.reminder.due": "thread.reminder.due";
+            }>, z.ZodString]>;
+            timeout: z.ZodOptional<z.ZodString>;
+            onTimeout: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        cancels: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+            "thread.message.received": "thread.message.received";
+            "thread.message.sent": "thread.message.sent";
+            "thread.participant.joined": "thread.participant.joined";
+            "thread.participant.left": "thread.participant.left";
+            "thread.participant.mentioned": "thread.participant.mentioned";
+            "thread.context.changed": "thread.context.changed";
+            "thread.status.changed": "thread.status.changed";
+            "thread.agent.delegated": "thread.agent.delegated";
+            "thread.agent.completed": "thread.agent.completed";
+            "thread.workflow.triggered": "thread.workflow.triggered";
+            "thread.workflow.completed": "thread.workflow.completed";
+            "thread.follow_up.due": "thread.follow_up.due";
+            "thread.reminder.due": "thread.reminder.due";
+        }>, z.ZodString]>>>;
+        cancelCondition: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    memory: z.ZodOptional<z.ZodObject<{
+        working: z.ZodOptional<z.ZodObject<{
+            strategy: z.ZodOptional<z.ZodEnum<{
+                full: "full";
+                rolling_summary: "rolling_summary";
+                sliding_window: "sliding_window";
+            }>>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            summarizeAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        persistent: z.ZodOptional<z.ZodObject<{
+            namespace: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        external: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            ttl: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        semantic: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            topK: z.ZodOptional<z.ZodNumber>;
+            scope: z.ZodOptional<z.ZodEnum<{
+                instance: "instance";
+                thread: "thread";
+                workspace: "workspace";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    policies: z.ZodOptional<z.ZodObject<{
+        response: z.ZodOptional<z.ZodObject<{
+            requiresApproval: z.ZodOptional<z.ZodBoolean>;
+            requiresApprovalIf: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        rules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    runtime: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        timeout: z.ZodOptional<z.ZodString>;
+        timezone: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodObject<{
+            attempts: z.ZodOptional<z.ZodNumber>;
+            backoff: z.ZodOptional<z.ZodEnum<{
+                linear: "linear";
+                exponential: "exponential";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    prompts: z.ZodOptional<z.ZodObject<{
+        recovery: z.ZodOptional<z.ZodString>;
+        followUp: z.ZodOptional<z.ZodString>;
+        skillDiscoveryWorkflow: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    sandbox: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        mockContext: z.ZodOptional<z.ZodObject<{
+            sender: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    contact: "contact";
+                    member: "member";
+                }>;
+                displayName: z.ZodOptional<z.ZodString>;
+                role: z.ZodOptional<z.ZodString>;
+                permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                contact: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodOptional<z.ZodString>;
+                    name: z.ZodOptional<z.ZodString>;
+                    subscription: z.ZodOptional<z.ZodObject<{
+                        identifierValue: z.ZodString;
+                        channelHandle: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    associations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        id: z.ZodOptional<z.ZodString>;
+                        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            contexts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                handle: z.ZodString;
+                model: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentYAMLV3 = z.infer<typeof AgentYAMLV3Schema>;
+/**
+ * Helper function to define an agent with type safety
+ */
+export declare function defineAgentV3(agent: AgentYAMLV3): AgentYAMLV3;
+/**
+ * Validate an agent YAML v3 object
+ */
+export declare function validateAgentYAMLV3(agent: unknown): {
+    success: true;
+    data: AgentYAMLV3;
+} | {
+    success: false;
+    error: z.ZodError;
+};