@elevasis/core 0.46.0 → 0.47.0

package/src/execution/engine/llm/adapters/__tests__/anthropic-adapter.test.ts

@@ -81,17 +81,18 @@ describe('AnthropicAdapter', () => {
     }
   }
 
-  describe('isAnthropicModel', () => {
-    it('returns true for claude models with anthropic provider', () => {
-      expect(isAnthropicModel('claude-opus-4-5', 'anthropic')).toBe(true)
-      expect(isAnthropicModel('claude-sonnet-4-5', 'anthropic')).toBe(true)
-      expect(isAnthropicModel('claude-haiku-4-5', 'anthropic')).toBe(true)
-    })
-
-    it('returns false for claude models with other providers', () => {
-      expect(isAnthropicModel('claude-opus-4-5', 'openrouter')).toBe(false)
-      expect(isAnthropicModel('claude-sonnet-4-5', 'google')).toBe(false)
-    })
+  describe('isAnthropicModel', () => {
+    it('returns true for claude models with anthropic provider', () => {
+      expect(isAnthropicModel('claude-opus-4-8', 'anthropic')).toBe(true)
+      expect(isAnthropicModel('claude-sonnet-4-6', 'anthropic')).toBe(true)
+      expect(isAnthropicModel('claude-haiku-4-5-20251001', 'anthropic')).toBe(true)
+      expect(isAnthropicModel('claude-haiku-4-5', 'anthropic')).toBe(true)
+    })
+
+    it('returns false for claude models with other providers', () => {
+      expect(isAnthropicModel('claude-opus-4-8', 'openrouter')).toBe(false)
+      expect(isAnthropicModel('claude-sonnet-4-6', 'google')).toBe(false)
+    })
 
     it('returns false for non-claude models', () => {
       expect(isAnthropicModel('gpt-5', 'anthropic')).toBe(false)
@@ -101,10 +102,10 @@ describe('AnthropicAdapter', () => {
 
   describe('Basic Configuration', () => {
     it('creates adapter without model options', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -114,11 +115,11 @@ describe('AnthropicAdapter', () => {
     })
 
     it('creates adapter with model options', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-opus-4-5',
-        modelOptions: {}
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-opus-4-8',
+        modelOptions: {}
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -130,10 +131,10 @@ describe('AnthropicAdapter', () => {
 
   describe('Message Translation', () => {
     it('converts system messages to separate system field', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -157,10 +158,10 @@ describe('AnthropicAdapter', () => {
     })
 
     it('combines multiple system messages', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -179,10 +180,10 @@ describe('AnthropicAdapter', () => {
     })
 
     it('handles requests without system messages', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -197,10 +198,10 @@ describe('AnthropicAdapter', () => {
     })
 
     it('preserves user and assistant roles', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -223,10 +224,10 @@ describe('AnthropicAdapter', () => {
 
   describe('Tool-based Structured Output', () => {
     it('configures tool_use for structured output', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -244,10 +245,10 @@ describe('AnthropicAdapter', () => {
     })
 
     it('extracts response from tool_use block', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse({
         content: [
@@ -278,10 +279,10 @@ describe('AnthropicAdapter', () => {
     })
 
     it('throws error when no tool_use block in response', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse({
         content: [{ type: 'text', text: 'Hello!' }],
@@ -296,10 +297,10 @@ describe('AnthropicAdapter', () => {
 
   describe('Usage Metadata', () => {
     it('calculates total tokens from input + output', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse({
         content: [mockAnthropicResponse.content[0]],
@@ -319,10 +320,10 @@ describe('AnthropicAdapter', () => {
     })
 
     it('extracts token usage correctly', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -338,10 +339,10 @@ describe('AnthropicAdapter', () => {
 
   describe('MaxTokens Configuration', () => {
     it('passes maxOutputTokens to API', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -355,10 +356,10 @@ describe('AnthropicAdapter', () => {
     })
 
     it('uses default 4000 when maxOutputTokens not specified', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -373,12 +374,12 @@ describe('AnthropicAdapter', () => {
     })
   })
 
-  describe('Temperature and TopP', () => {
-    it('passes temperature to API', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+  describe('Temperature and TopP', () => {
+    it('passes temperature to API', async () => {
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -392,10 +393,10 @@ describe('AnthropicAdapter', () => {
     })
 
     it('passes topP to API', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponse(mockAnthropicResponse)
 
@@ -404,17 +405,37 @@ describe('AnthropicAdapter', () => {
         topP: 0.9
       })
 
-      const callParams = mockMessagesStream.mock.calls[0][0]
-      expect(callParams.top_p).toBe(0.9)
-    })
-  })
+      const callParams = mockMessagesStream.mock.calls[0][0]
+      expect(callParams.top_p).toBe(0.9)
+    })
+
+    it('omits sampling parameters for Opus 4.8', async () => {
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-opus-4-8'
+      })
+
+      mockStreamResponse(mockAnthropicResponse)
+
+      await adapter.generate({
+        ...baseRequest,
+        temperature: 0.7,
+        topP: 0.9
+      })
+
+      const callParams = mockMessagesStream.mock.calls[0][0]
+      expect(callParams).not.toHaveProperty('temperature')
+      expect(callParams).not.toHaveProperty('top_p')
+      expect(callParams).not.toHaveProperty('top_k')
+    })
+  })
 
   describe('Error Handling', () => {
     it('propagates API errors', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-sonnet-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       const apiError = new Error('API rate limit exceeded')
       mockStreamError(apiError)
@@ -425,10 +446,10 @@ describe('AnthropicAdapter', () => {
 
   describe('Multiple Calls', () => {
     it('reuses client across multiple generate calls', async () => {
-      const adapter = new AnthropicAdapter({
-        apiKey: 'test-key',
-        model: 'claude-opus-4-5'
-      })
+      const adapter = new AnthropicAdapter({
+        apiKey: 'test-key',
+        model: 'claude-sonnet-4-6'
+      })
 
       mockStreamResponsePersistent(mockAnthropicResponse)
 
@@ -443,7 +464,7 @@ describe('AnthropicAdapter', () => {
   })
 
   describe('Model Selection', () => {
-    it.each(['claude-opus-4-5', 'claude-sonnet-4-5', 'claude-haiku-4-5'] as const)(
+    it.each(['claude-opus-4-8', 'claude-sonnet-4-6', 'claude-haiku-4-5-20251001', 'claude-haiku-4-5'] as const)(
       'supports %s model',
       async (model) => {
         const adapter = new AnthropicAdapter({

package/src/execution/engine/llm/adapters/server/anthropic.ts

@@ -25,19 +25,34 @@ export interface AnthropicAdapterConfig {
 }
 
 /**
- * Check if the model and provider combination is for Anthropic
- *
- * @param model - Model identifier (e.g., 'claude-opus-4-5-20251101')
- * @param provider - Provider name
- * @returns True if this is an Anthropic model configuration
- */
-export function isAnthropicModel(model: LLMModel, provider: string): boolean {
-  return model.startsWith('claude-') && provider === 'anthropic'
-}
-
-/**
- * Anthropic Claude Adapter - Implements universal protocol
- * Uses tool_use for structured output (Anthropic's recommended approach)
+ * Check if the model and provider combination is for Anthropic
+ *
+ * @param model - Model identifier (e.g., 'claude-opus-4-8')
+ * @param provider - Provider name
+ * @returns True if this is an Anthropic model configuration
+ */
+export function isAnthropicModel(model: LLMModel, provider: string): boolean {
+  return model.startsWith('claude-') && provider === 'anthropic'
+}
+
+function shouldOmitSamplingParameters(model: LLMModel): boolean {
+  return model === 'claude-opus-4-8'
+}
+
+function getSamplingParameters(model: LLMModel, request: LLMGenerateRequest): { temperature?: number; top_p?: number } {
+  if (shouldOmitSamplingParameters(model)) {
+    return {}
+  }
+
+  return {
+    ...(request.temperature !== undefined ? { temperature: request.temperature } : {}),
+    ...(request.topP !== undefined ? { top_p: request.topP } : {})
+  }
+}
+
+/**
+ * Anthropic Claude Adapter - Implements universal protocol
+ * Uses tool_use for structured output (Anthropic's recommended approach)
  *
  * Key differences from other adapters:
  * - System messages go in separate `system` field (not in messages array)
@@ -87,10 +102,10 @@ export class AnthropicAdapter implements LLMAdapter {
       // This guarantees schema compliance without requiring JSON mode
       // Stream + finalMessage() to avoid SDK non-streaming timeout rejection
       // at high max_tokens values (SDK calculates estimated time > 10 min → error)
-      const stream = client.messages.stream(
-        {
-          model: this.model,
-          max_tokens: request.maxOutputTokens || 4000, // Required for Anthropic
+      const stream = client.messages.stream(
+        {
+          model: this.model,
+          max_tokens: request.maxOutputTokens || 4000, // Required for Anthropic
           system: systemContent,
           messages: anthropicMessages,
           tools: [
@@ -99,13 +114,12 @@ export class AnthropicAdapter implements LLMAdapter {
               description: 'Return structured output matching the required schema',
               input_schema: request.responseSchema as import('@anthropic-ai/sdk').Anthropic.Tool['input_schema']
             }
-          ],
-          tool_choice: { type: 'tool', name: 'structured_output' },
-          temperature: request.temperature,
-          top_p: request.topP
-        },
-        { signal: composeSignal(DEFAULT_LLM_TIMEOUT, request.signal) }
-      )
+          ],
+          tool_choice: { type: 'tool', name: 'structured_output' },
+          ...getSamplingParameters(this.model, request)
+        },
+        { signal: composeSignal(DEFAULT_LLM_TIMEOUT, request.signal) }
+      )
       const response = await stream.finalMessage()
 
       // Extract structured output from tool_use block

package/src/execution/engine/llm/model-info.ts

@@ -26,10 +26,15 @@ export type OpenRouterModel = 'openrouter/z-ai/glm-5'
  */
 export type GoogleModel = 'gemini-3-flash-preview' | 'gemini-3.1-flash-lite-preview'
 
-/**
- * Supported Anthropic models (direct SDK access via @anthropic-ai/sdk)
- */
-export type AnthropicModel = 'claude-sonnet-4-5'
+/**
+ * Supported Anthropic models (direct SDK access via @anthropic-ai/sdk)
+ */
+export type AnthropicModel =
+  | 'claude-opus-4-8'
+  | 'claude-sonnet-4-6'
+  | 'claude-haiku-4-5-20251001'
+  | 'claude-haiku-4-5'
+  | 'claude-sonnet-4-5'
 
 /** Supported LLM models */
 export type LLMModel = OpenAIModel | OpenRouterModel | GoogleModel | AnthropicModel | 'mock'
@@ -122,26 +127,48 @@ export const GoogleConfigSchema = z.object({
   modelOptions: GoogleOptionsSchema.optional()
 })
 
-/**
- * Anthropic model options schema
- * Currently empty - future options: budget_tokens for extended thinking
- */
-const AnthropicOptionsSchema = z.object({})
-
-/**
- * Anthropic config schema
- * Validates ModelConfig for Anthropic provider (direct SDK access)
- */
-export const AnthropicConfigSchema = z.object({
-  model: z.enum(['claude-sonnet-4-5']),
-  provider: z.literal('anthropic'),
-  apiKey: z.string(),
-  temperature: z.number().min(0).max(1).optional(),
-  maxOutputTokens: z.number().min(1000).optional(), // Anthropic requires max_tokens
-  topP: z.number().min(0).max(1).optional(),
-  modelOptions: AnthropicOptionsSchema.optional()
-})
+/**
+ * Anthropic model options schema
+ * Currently empty - future options must be added per supported model family
+ */
+const AnthropicOptionsSchema = z.object({}).strict()
 
+/**
+ * Anthropic config schema
+ * Validates ModelConfig for Anthropic provider (direct SDK access)
+ */
+const AnthropicStandardConfigSchema = z.object({
+  model: z.enum([
+    'claude-sonnet-4-6',
+    'claude-haiku-4-5-20251001',
+    'claude-haiku-4-5',
+    'claude-sonnet-4-5'
+  ]),
+  provider: z.literal('anthropic'),
+  apiKey: z.string(),
+  temperature: z.number().min(0).max(1).optional(),
+  maxOutputTokens: z.number().min(1000).max(64000).optional(), // Anthropic requires max_tokens
+  topP: z.number().min(0).max(1).optional(),
+  modelOptions: AnthropicOptionsSchema.optional()
+})
+
+const AnthropicOpus48ConfigSchema = z.object({
+  model: z.literal('claude-opus-4-8'),
+  provider: z.literal('anthropic'),
+  apiKey: z.string(),
+  temperature: z.literal(1).optional(),
+  maxOutputTokens: z.number().min(1000).max(128000).optional(), // Anthropic requires max_tokens
+  topP: z.literal(1).optional(),
+  topK: z.undefined().optional(),
+  top_k: z.undefined().optional(),
+  modelOptions: AnthropicOptionsSchema.optional()
+})
+
+export const AnthropicConfigSchema = z.discriminatedUnion('model', [
+  AnthropicOpus48ConfigSchema,
+  AnthropicStandardConfigSchema
+])
+
 /**
  * Infer TypeScript types from schemas
  */
@@ -191,16 +218,18 @@ export interface ModelInfo {
   minTokens: number
   /** Recommended tokens for production use (typically 2x minimum) */
   recommendedTokens: number
-  /** Maximum context window size (total tokens: input + output) */
-  maxTokens: number
-  /** Model category for grouping and documentation */
-  category: 'reasoning' | 'standard' | 'embedding'
-  /** Zod schema for validating complete ModelConfig (replaces constraints + optionsSchema) */
-  configSchema?: z.ZodType<ModelConfig>
-}
+  /** Maximum context window size (total tokens: input + output) */
+  maxTokens: number
+  /** Maximum output tokens supported by the synchronous generation API */
+  maxOutputTokens?: number
+  /** Model category for grouping and documentation */
+  category: 'reasoning' | 'standard' | 'embedding'
+  /** Zod schema for validating complete ModelConfig (replaces constraints + optionsSchema) */
+  configSchema?: z.ZodType<ModelConfig>
+}
 
-// Model configuration as of 2026-03-17
-export const MODEL_INFO: Record<LLMModel, ModelInfo> = {
+// Model configuration as of 2026-06-09
+export const MODEL_INFO: Record<LLMModel, ModelInfo> = {
   // OpenAI GPT-5 (Reasoning Models)
   'gpt-5': {
     inputCostPer1M: 125, // $1.25 per 1M tokens
@@ -268,17 +297,58 @@ export const MODEL_INFO: Record<LLMModel, ModelInfo> = {
     category: 'standard',
     configSchema: GoogleConfigSchema
   },
-  // Anthropic Claude Models (direct SDK access via @anthropic-ai/sdk)
-  'claude-sonnet-4-5': {
-    inputCostPer1M: 300, // $3.00 per 1M tokens
-    outputCostPer1M: 1500, // $15.00 per 1M tokens
-    minTokens: 4000,
-    recommendedTokens: 8000,
-    maxTokens: 200000, // 200k context window
-    category: 'standard',
-    configSchema: AnthropicConfigSchema
-  }
-}
+  // Anthropic Claude Models (direct SDK access via @anthropic-ai/sdk)
+  'claude-opus-4-8': {
+    inputCostPer1M: 500, // $5.00 per 1M tokens
+    outputCostPer1M: 2500, // $25.00 per 1M tokens
+    minTokens: 4000,
+    recommendedTokens: 8000,
+    maxTokens: 1000000, // 1M context window
+    maxOutputTokens: 128000,
+    category: 'reasoning',
+    configSchema: AnthropicConfigSchema
+  },
+  'claude-sonnet-4-6': {
+    inputCostPer1M: 300, // $3.00 per 1M tokens
+    outputCostPer1M: 1500, // $15.00 per 1M tokens
+    minTokens: 4000,
+    recommendedTokens: 8000,
+    maxTokens: 1000000, // 1M context window
+    maxOutputTokens: 64000,
+    category: 'standard',
+    configSchema: AnthropicConfigSchema
+  },
+  'claude-haiku-4-5-20251001': {
+    inputCostPer1M: 100, // $1.00 per 1M tokens
+    outputCostPer1M: 500, // $5.00 per 1M tokens
+    minTokens: 4000,
+    recommendedTokens: 8000,
+    maxTokens: 200000, // 200k context window
+    maxOutputTokens: 64000,
+    category: 'standard',
+    configSchema: AnthropicConfigSchema
+  },
+  'claude-haiku-4-5': {
+    inputCostPer1M: 100, // $1.00 per 1M tokens
+    outputCostPer1M: 500, // $5.00 per 1M tokens
+    minTokens: 4000,
+    recommendedTokens: 8000,
+    maxTokens: 200000, // 200k context window
+    maxOutputTokens: 64000,
+    category: 'standard',
+    configSchema: AnthropicConfigSchema
+  },
+  'claude-sonnet-4-5': {
+    inputCostPer1M: 300, // $3.00 per 1M tokens
+    outputCostPer1M: 1500, // $15.00 per 1M tokens
+    minTokens: 4000,
+    recommendedTokens: 8000,
+    maxTokens: 200000, // 200k context window
+    maxOutputTokens: 64000,
+    category: 'standard',
+    configSchema: AnthropicConfigSchema
+  }
+}
 
 /**
  * Get model information (pricing and token requirements)

package/src/operations/index.ts

@@ -22,17 +22,19 @@ export type {
 
 // Session validation schemas
 export {
-  CreateSessionSchema,
-  ExecuteTurnSchema,
-  ListSessionsQuerySchema,
-  SessionIdParamSchema,
-  ExecutionIdParamsSchema,
-  WebSocketSessionTurnSchema,
-  type CreateSessionInput,
-  type ExecuteTurnInput,
-  type ListSessionsQuery,
-  type WebSocketSessionTurnMessage
-} from './sessions'
+  CreateSessionSchema,
+  ExecuteTurnSchema,
+  ListSessionsQuerySchema,
+  SessionMessagesQuerySchema,
+  SessionIdParamSchema,
+  ExecutionIdParamsSchema,
+  WebSocketSessionTurnSchema,
+  type CreateSessionInput,
+  type ExecuteTurnInput,
+  type ListSessionsQuery,
+  type SessionMessagesQuery,
+  type WebSocketSessionTurnMessage
+} from './sessions'
 
 // Notification types and validation schemas
 export * from './notifications/index'
@@ -46,5 +48,8 @@ export * from './activities/index'
 // Triggers (includes webhook providers and trigger definitions)
 export * from './triggers/index'
 
-// Debug Logs
-export * from './debug-logs/index'
+// Debug Logs
+export * from './debug-logs/index'
+
+// Public agent chat route schemas
+export * from './public-agent-chat'

package/src/operations/public-agent-chat/api-schemas.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod'
+import { UuidSchema } from '../../platform/utils/validation'
+
+export const PublicAgentChatSlugParamSchema = z
+  .object({
+    slug: z.string().min(1).max(120).regex(/^[a-zA-Z0-9._-]+$/)
+  })
+  .strict()
+
+export const PublicAgentChatSessionParamSchema = z
+  .object({
+    sessionId: UuidSchema
+  })
+  .strict()
+
+export const PublicAgentChatAuthorizeSchema = z
+  .object({
+    code: z.string().min(1).max(200).optional(),
+    visitorId: z.string().min(1).max(120).optional()
+  })
+  .strict()
+
+export const PublicAgentChatCreateSessionSchema = z
+  .object({
+    capabilityToken: z.string().min(32).optional(),
+    metadata: z.record(z.string(), z.unknown()).optional()
+  })
+  .strict()
+
+export const PublicAgentChatCapabilityQuerySchema = z
+  .object({
+    token: z.string().min(32)
+  })
+  .strict()
+
+export type PublicAgentChatSlugParams = z.infer<typeof PublicAgentChatSlugParamSchema>
+export type PublicAgentChatSessionParams = z.infer<typeof PublicAgentChatSessionParamSchema>
+export type PublicAgentChatAuthorizeInput = z.infer<typeof PublicAgentChatAuthorizeSchema>
+export type PublicAgentChatCreateSessionInput = z.infer<typeof PublicAgentChatCreateSessionSchema>
+export type PublicAgentChatCapabilityQuery = z.infer<typeof PublicAgentChatCapabilityQuerySchema>