@defai.digital/ax-schemas 1.0.0

package/README.md

@@ -0,0 +1,388 @@
+# @ax-cli/schemas
+
+Single Source of Truth (SSOT) Type System for AX CLI.
+
+This package provides centralized Zod schemas, brand types, and enums for the entire ax-cli ecosystem, ensuring type safety and runtime validation across all modules.
+
+## Installation
+
+```bash
+npm install @ax-cli/schemas
+```
+
+## What is Single Source of Truth (SSOT)?
+
+**Single Source of Truth (SSOT)**: All modules (API / MCP / Usage) share the same type definition contract.
+
+Before @ax-cli/schemas, type definitions were scattered across the codebase, leading to:
+- Duplicated schema definitions
+- Inconsistent validation logic
+- Type mismatches between modules
+- High refactoring costs
+
+### Architecture: Before vs. After
+
+**BEFORE** (Distributed, Inconsistent):
+```
+┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
+│   API Handler   │     │   MCP Adapter   │     │  Usage Module   │
+├─────────────────┤     ├─────────────────┤     ├─────────────────┤
+│ • Own schemas   │     │ • Own schemas   │     │ • Own schemas   │
+│ • Own types     │     │ • Own types     │     │ • Own types     │
+│ • Own enums     │     │ • Own enums     │     │ • Own enums     │
+└─────────────────┘     └─────────────────┘     └─────────────────┘
+      ❌                       ❌                       ❌
+   Duplicated              Duplicated              Duplicated
+   Diverges over time      Diverges over time      Diverges over time
+```
+
+**AFTER** (Centralized, Consistent):
+```
+                    ┌──────────────────────────────┐
+                    │      @ax-cli/schemas         │
+                    ├──────────────────────────────┤
+                    │ • Brand Types (ID safety)    │
+                    │ • Centralized Enums          │
+                    │ • Zod Schemas (validation)   │
+                    │ • TypeScript Types           │
+                    └───────────────┬──────────────┘
+                                    │
+                      ┌─────────────┼─────────────┐
+                      │             │             │
+                      ▼             ▼             ▼
+            ┌─────────────┐ ┌─────────────┐ ┌─────────────┐
+            │ API Handler │ │ MCP Adapter │ │Usage Module │
+            ├─────────────┤ ├─────────────┤ ├─────────────┤
+            │ import {...}│ │ import {...}│ │ import {...}│
+            │ from        │ │ from        │ │ from        │
+            │ '@ax-cli/   │ │ '@ax-cli/   │ │ '@ax-cli/   │
+            │  schemas'   │ │  schemas'   │ │  schemas'   │
+            └─────────────┘ └─────────────┘ └─────────────┘
+                  ✅               ✅               ✅
+              Same contract   Same contract   Same contract
+```
+
+### Benefits
+
+**1. Zero Divergence**
+All modules consume the same source - when you update `ModelId` schema, all consumers get the update automatically.
+
+**2. Reduced Refactoring Cost**
+Change once in `@ax-cli/schemas`, propagate everywhere. No need to hunt down all duplicate definitions.
+
+**3. Compile-Time Safety**
+TypeScript catches type mismatches across module boundaries:
+```typescript
+// API handler expects ModelId
+function handleRequest(model: ModelId) { ... }
+
+// MCP adapter provides ModelId (same type!)
+const mcpModel = ModelIdSchema.parse(input);
+handleRequest(mcpModel);  // ✅ Type-safe!
+
+// Usage module also uses ModelId (same type!)
+const usageModel = getModelFromDB();  // Returns ModelId
+handleRequest(usageModel);  // ✅ Type-safe!
+```
+
+**4. Runtime Validation Consistency**
+All modules use the same Zod schemas, ensuring consistent validation rules across API boundaries, MCP adapters, and usage tracking.
+
+## Features
+
+- **Brand Types**: Compile-time nominal typing for ID types to prevent mixing
+- **Centralized Enums**: Single source of truth for all enum values
+- **Zod Schemas**: Runtime validation with TypeScript type inference
+- **Zero Runtime Cost**: Brand types are compile-time only (erased during compilation)
+- **100% Test Coverage**: Comprehensive test suite (123 tests)
+
+## Quick Start
+
+### Using Brand Types
+
+```typescript
+import { ModelId, ModelIdSchema } from '@ax-cli/schemas';
+
+// ✅ Safe: Runtime validation + branding
+const modelId = ModelIdSchema.parse('glm-4.6');
+
+// ✅ Type-safe function signatures
+function getModelConfig(id: ModelId) {
+  // TypeScript prevents passing other ID types here
+}
+
+// ❌ Compile error: Can't pass plain string
+getModelConfig('glm-4.6'); // TypeScript error!
+
+// ✅ Correct: Parse first
+getModelConfig(ModelIdSchema.parse('glm-4.6'));
+```
+
+### Using Enums
+
+```typescript
+import { MessageRoleEnum, type MessageRole } from '@ax-cli/schemas';
+
+// ✅ Use in Zod schemas
+const MessageSchema = z.object({
+  role: MessageRoleEnum,
+  content: z.string(),
+});
+
+// ✅ Use type for function signatures
+function handleMessage(role: MessageRole, content: string) {
+  // role is typed as 'system' | 'user' | 'assistant' | 'tool'
+}
+```
+
+## API Reference
+
+### Brand Types
+
+All ID types are branded to prevent accidental mixing:
+
+```typescript
+import {
+  ApiResponseId,
+  ToolCallId,
+  ModelId,
+  MCPServerId,
+  // ... and their corresponding schemas
+  ApiResponseIdSchema,
+  ToolCallIdSchema,
+  ModelIdSchema,
+  MCPServerIdSchema,
+} from '@ax-cli/schemas';
+```
+
+**Available Brand Types:**
+- `ApiResponseId` / `ApiResponseIdSchema`
+- `ToolCallId` / `ToolCallIdSchema`
+- `ModelId` / `ModelIdSchema`
+- `TenantId` / `TenantIdSchema`
+- `ApiKeyId` / `ApiKeyIdSchema`
+- `MCPServerId` / `MCPServerIdSchema`
+- `UsageRecordId` / `UsageRecordIdSchema`
+- `PlanId` / `PlanIdSchema`
+- `SessionId` / `SessionIdSchema`
+- `RequestId` / `RequestIdSchema`
+
+### Enums
+
+```typescript
+import {
+  MessageRoleEnum,
+  FinishReasonEnum,
+  TransportEnum,
+  EditorCommandEnum,
+} from '@ax-cli/schemas';
+```
+
+**MessageRoleEnum**: `'system' | 'user' | 'assistant' | 'tool'`
+
+**FinishReasonEnum**: `'stop' | 'length' | 'tool_calls' | 'content_filter'`
+
+**TransportEnum**: `'stdio' | 'http' | 'sse'`
+
+**EditorCommandEnum**: `'view' | 'create' | 'str_replace' | 'insert' | 'undo_edit'`
+
+### Brand Type Utilities
+
+```typescript
+import {
+  brand,
+  unbrand,
+  isBranded,
+  createBrandFactory,
+  type Brand,
+} from '@ax-cli/schemas';
+
+// Create custom brand types
+const MyIdSchema = z.string().transform((val) => brand<string, 'MyId'>(val));
+type MyId = Brand<string, 'MyId'>;
+
+// Remove branding (use sparingly!)
+const plainString = unbrand(brandedId);
+
+// Check if value is branded
+if (isBranded(value, 'ModelId')) {
+  // TypeScript knows this is a ModelId
+}
+```
+
+## Security Best Practices
+
+### CRITICAL: Brand Types Are Compile-Time Only
+
+Brand types provide **ZERO runtime validation**. You **MUST** validate all external inputs at system boundaries.
+
+```typescript
+// ❌ UNSAFE: No runtime validation!
+const tenantId = userInput as TenantId; // DON'T DO THIS!
+
+// ✅ SAFE: Validates with Zod
+const result = TenantIdSchema.safeParse(userInput);
+if (result.success) {
+  const tenantId = result.data; // Type-safe AND runtime-safe
+}
+```
+
+### When to Validate
+
+Always validate at these boundaries:
+
+- **API boundaries**: HTTP requests, MCP inputs
+- **File I/O**: Reading configs, user settings
+- **Database queries**: WHERE clauses with user IDs
+- **Environment variables**
+- **Command-line arguments**
+
+### Safe Validation Pattern
+
+```typescript
+import { ModelIdSchema, type ModelId } from '@ax-cli/schemas';
+
+function updateModel(modelName: string): void {
+  // ✅ Validate at boundary
+  const result = ModelIdSchema.safeParse(modelName);
+
+  if (!result.success) {
+    throw new Error(`Invalid model ID: ${result.error.message}`);
+  }
+
+  // Now we have a branded ModelId
+  const modelId: ModelId = result.data;
+
+  // Use in type-safe functions
+  processModel(modelId);
+}
+
+function processModel(id: ModelId): void {
+  // TypeScript ensures only ModelId can be passed here
+  // No accidental mixing with other ID types!
+}
+```
+
+## Migration Guide
+
+### Adding Brand Types to Existing Code
+
+**Step 1**: Import the schema
+
+```typescript
+import { ModelIdSchema } from '@ax-cli/schemas';
+```
+
+**Step 2**: Use `.parse()` at object creation boundaries
+
+```typescript
+// Before
+const config = {
+  model: 'glm-4.6',  // Plain string
+};
+
+// After
+const config = {
+  model: ModelIdSchema.parse('glm-4.6'),  // Branded ModelId
+};
+```
+
+**Step 3**: Update function signatures
+
+```typescript
+// Before
+function getConfig(model: string) { }
+
+// After
+function getConfig(model: ModelId) { }
+```
+
+**Step 4**: Fix TypeScript errors by adding `.parse()` at call sites
+
+```typescript
+// Before
+getConfig('glm-4.6');  // Now causes TypeScript error
+
+// After
+getConfig(ModelIdSchema.parse('glm-4.6'));  // Type-safe!
+```
+
+### Default Values
+
+For constants and defaults, parse at definition:
+
+```typescript
+import { ModelIdSchema } from '@ax-cli/schemas';
+
+const DEFAULT_CONFIG = {
+  model: ModelIdSchema.parse('glm-4.6'),
+  // ... other fields
+};
+```
+
+## Performance
+
+- **Brand types**: Zero runtime cost (compile-time only)
+- **Zod validation**: ~1-2μs per validation (negligible)
+- **Test performance**: 123 tests in <20ms
+
+## Testing
+
+```bash
+# Run tests
+npm test
+
+# Run tests in watch mode
+npm run test:watch
+
+# Type checking
+npm run typecheck
+
+# Build
+npm run build
+```
+
+## Architecture
+
+```
+packages/schemas/
+├── src/
+│   ├── index.ts                    # Public API
+│   ├── public/
+│   │   └── core/
+│   │       ├── brand-types.ts      # Brand type utilities
+│   │       ├── enums.ts            # Centralized enums
+│   │       └── id-types.ts         # ID brand types
+│   └── __tests__/
+│       ├── brand-types.test.ts     # 40 tests
+│       ├── enums.test.ts           # 31 tests
+│       └── id-types.test.ts        # 52 tests
+└── dist/                           # Compiled output
+```
+
+## Version
+
+Current version: 1.0.0
+
+## License
+
+MIT
+
+## Related Packages
+
+- `@ax-cli/schemas` (this package): Type system foundation
+- `ax-cli`: Main CLI application
+
+## Contributing
+
+When adding new brand types or enums:
+
+1. Add implementation to `src/public/core/`
+2. Export from `src/index.ts`
+3. Add comprehensive tests
+4. Update this README
+5. Run `npm test` and `npm run typecheck`
+
+## Support
+
+For issues and questions, please open an issue in the main ax-cli repository.

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @ax-cli/schemas - Single Source of Truth Type System
+ *
+ * This package provides centralized Zod schemas, brand types, and enums
+ * for the entire ax-cli ecosystem.
+ *
+ * SECURITY: All exports are controlled. Internal helpers are not exposed.
+ *
+ * @packageDocumentation
+ */
+export { brand, unbrand, isBranded, createBrandFactory, type __brand, type Brand, type ExtractBrand, type ExtractBase, } from './public/core/brand-types.js';
+export { ApiResponseId, ToolCallId, ToolCallIdSchema, ModelId, ModelIdSchema, TenantId, ApiKeyId, MCPServerId, MCPServerIdSchema, UsageRecordId, PlanId, SessionId, RequestId, type ApiResponseId as ApiResponseIdType, type ToolCallId as ToolCallIdType, type ModelId as ModelIdType, type TenantId as TenantIdType, type ApiKeyId as ApiKeyIdType, type MCPServerId as MCPServerIdType, type UsageRecordId as UsageRecordIdType, type PlanId as PlanIdType, type SessionId as SessionIdType, type RequestId as RequestIdType, } from './public/core/id-types.js';
+export { MessageRoleEnum, FinishReasonEnum, TransportEnum, EditorCommandEnum, type MessageRole, type FinishReason, type Transport, type EditorCommand, } from './public/core/enums.js';
+export { type LLMToolCallRef, type ToolResultRef, type ChatEntry, type StreamingChunkType, type StreamingChunk, type AccumulatedMessage, type ChatHistory, } from './public/agent/index.js';
+export * from './public/design/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EACL,KAAK,EACL,OAAO,EACP,SAAS,EACT,kBAAkB,EAClB,KAAK,OAAO,EACZ,KAAK,KAAK,EACV,KAAK,YAAY,EACjB,KAAK,WAAW,GACjB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EACL,aAAa,EACb,UAAU,EACV,gBAAgB,EAChB,OAAO,EACP,aAAa,EACb,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,iBAAiB,EACjB,aAAa,EACb,MAAM,EACN,SAAS,EACT,SAAS,EACT,KAAK,aAAa,IAAI,iBAAiB,EACvC,KAAK,UAAU,IAAI,cAAc,EACjC,KAAK,OAAO,IAAI,WAAW,EAC3B,KAAK,QAAQ,IAAI,YAAY,EAC7B,KAAK,QAAQ,IAAI,YAAY,EAC7B,KAAK,WAAW,IAAI,eAAe,EACnC,KAAK,aAAa,IAAI,iBAAiB,EACvC,KAAK,MAAM,IAAI,UAAU,EACzB,KAAK,SAAS,IAAI,aAAa,EAC/B,KAAK,SAAS,IAAI,aAAa,GAChC,MAAM,2BAA2B,CAAC;AAGnC,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,aAAa,GACnB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,WAAW,GACjB,MAAM,yBAAyB,CAAC;AAGjC,cAAc,0BAA0B,CAAC"}

package/dist/index.js

@@ -0,0 +1,19 @@
+/**
+ * @ax-cli/schemas - Single Source of Truth Type System
+ *
+ * This package provides centralized Zod schemas, brand types, and enums
+ * for the entire ax-cli ecosystem.
+ *
+ * SECURITY: All exports are controlled. Internal helpers are not exposed.
+ *
+ * @packageDocumentation
+ */
+// Core brand type utilities
+export { brand, unbrand, isBranded, createBrandFactory, } from './public/core/brand-types.js';
+// ID Brand Types
+export { ApiResponseId, ToolCallId, ToolCallIdSchema, ModelId, ModelIdSchema, TenantId, ApiKeyId, MCPServerId, MCPServerIdSchema, UsageRecordId, PlanId, SessionId, RequestId, } from './public/core/id-types.js';
+// Centralized Enums
+export { MessageRoleEnum, FinishReasonEnum, TransportEnum, EditorCommandEnum, } from './public/core/enums.js';
+// Design Module (Figma integration)
+export * from './public/design/index.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,4BAA4B;AAC5B,OAAO,EACL,KAAK,EACL,OAAO,EACP,SAAS,EACT,kBAAkB,GAKnB,MAAM,8BAA8B,CAAC;AAEtC,iBAAiB;AACjB,OAAO,EACL,aAAa,EACb,UAAU,EACV,gBAAgB,EAChB,OAAO,EACP,aAAa,EACb,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,iBAAiB,EACjB,aAAa,EACb,MAAM,EACN,SAAS,EACT,SAAS,GAWV,MAAM,2BAA2B,CAAC;AAEnC,oBAAoB;AACpB,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,iBAAiB,GAKlB,MAAM,wBAAwB,CAAC;AAahC,oCAAoC;AACpC,cAAc,0BAA0B,CAAC"}

package/dist/public/agent/chat-types.d.ts

@@ -0,0 +1,164 @@
+/**
+ * @ax-cli/schemas - Agent Chat Types
+ *
+ * Single Source of Truth (SSOT) for agent chat-related types.
+ * These types are used across the agent, UI, checkpoint, and SDK modules.
+ *
+ * @packageDocumentation
+ */
+/**
+ * LLM Tool Call representation
+ *
+ * Represents a tool call made by the LLM during a conversation.
+ * This is a simplified version that doesn't depend on OpenAI types.
+ */
+export interface LLMToolCallRef {
+    /** Unique identifier for this tool call */
+    id: string;
+    /** Type of tool call (always "function" for now) */
+    type: "function";
+    /** Function details */
+    function: {
+        /** Name of the function to call */
+        name: string;
+        /** JSON-encoded arguments string */
+        arguments: string;
+    };
+}
+/**
+ * Tool execution result
+ *
+ * Represents the result of executing a tool.
+ */
+export interface ToolResultRef {
+    /** Whether the tool execution succeeded */
+    success: boolean;
+    /** Output from successful execution */
+    output?: string;
+    /** Error message if execution failed */
+    error?: string;
+    /** Additional structured data from the tool */
+    data?: Record<string, unknown>;
+}
+/**
+ * Chat Entry
+ *
+ * Represents a single entry in the chat history between user and assistant.
+ * This is the canonical definition - DO NOT duplicate this type elsewhere.
+ *
+ * @example
+ * ```typescript
+ * const userMessage: ChatEntry = {
+ *   type: "user",
+ *   content: "Hello, how are you?",
+ *   timestamp: new Date(),
+ * };
+ *
+ * const assistantMessage: ChatEntry = {
+ *   type: "assistant",
+ *   content: "I'm doing well, thank you!",
+ *   timestamp: new Date(),
+ *   durationMs: 1500,
+ * };
+ * ```
+ */
+export interface ChatEntry {
+    /** Type of chat entry */
+    type: "user" | "assistant" | "tool_result" | "tool_call";
+    /** Text content of the entry */
+    content: string;
+    /** When this entry was created */
+    timestamp: Date;
+    /** Tool calls made by assistant (for type="assistant") */
+    toolCalls?: LLMToolCallRef[];
+    /** Single tool call (for type="tool_call") */
+    toolCall?: LLMToolCallRef;
+    /** Result of tool execution (for type="tool_result") */
+    toolResult?: {
+        success: boolean;
+        output?: string;
+        error?: string;
+    };
+    /** Whether content is currently streaming */
+    isStreaming?: boolean;
+    /** GLM-4.6 reasoning content (thinking mode) */
+    reasoningContent?: string;
+    /** Whether reasoning is currently streaming */
+    isReasoningStreaming?: boolean;
+    /** Response duration in milliseconds */
+    durationMs?: number;
+    /** Tool execution start time (for elapsed time display while running) */
+    executionStartTime?: Date;
+    /** Tool execution duration in milliseconds (shown after completion) */
+    executionDurationMs?: number;
+}
+/**
+ * Streaming Chunk Types
+ *
+ * Represents different types of streaming chunks that can be received
+ * during a streaming response from the LLM.
+ */
+export type StreamingChunkType = "content" | "reasoning" | "tool_calls" | "tool_result" | "done" | "token_count";
+/**
+ * Streaming Chunk
+ *
+ * Represents a chunk of data received during streaming response.
+ * Used by UI components to render incremental updates.
+ *
+ * @example
+ * ```typescript
+ * // Content chunk
+ * const contentChunk: StreamingChunk = {
+ *   type: "content",
+ *   content: "Hello",
+ * };
+ *
+ * // Tool result chunk
+ * const toolResultChunk: StreamingChunk = {
+ *   type: "tool_result",
+ *   toolResult: { success: true, output: "File created" },
+ *   executionDurationMs: 150,
+ * };
+ * ```
+ */
+export interface StreamingChunk {
+    /** Type of streaming chunk */
+    type: StreamingChunkType;
+    /** Text content (for type="content") */
+    content?: string;
+    /** GLM-4.6 reasoning content chunk (for type="reasoning") */
+    reasoningContent?: string;
+    /** Tool calls from LLM (for type="tool_calls") */
+    toolCalls?: LLMToolCallRef[];
+    /** Single tool call */
+    toolCall?: LLMToolCallRef;
+    /** Tool execution result (for type="tool_result") */
+    toolResult?: ToolResultRef;
+    /** Token count (for type="token_count") */
+    tokenCount?: number;
+    /** Tool execution duration in milliseconds (for type="tool_result") */
+    executionDurationMs?: number;
+}
+/**
+ * Accumulated Message
+ *
+ * Contains the full message content accumulated from streaming response.
+ * Used internally by the agent to build complete messages from chunks.
+ */
+export interface AccumulatedMessage {
+    /** Message role (e.g., "assistant") */
+    role?: string;
+    /** Full accumulated content */
+    content?: string;
+    /** Tool calls accumulated from the response */
+    tool_calls?: LLMToolCallRef[];
+    /** Allow additional properties for flexibility */
+    [key: string]: unknown;
+}
+/**
+ * Chat History
+ *
+ * Type alias for an array of chat entries.
+ */
+export type ChatHistory = ChatEntry[];
+//# sourceMappingURL=chat-types.d.ts.map

package/dist/public/agent/chat-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-types.d.ts","sourceRoot":"","sources":["../../../src/public/agent/chat-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,2CAA2C;IAC3C,EAAE,EAAE,MAAM,CAAC;IACX,oDAAoD;IACpD,IAAI,EAAE,UAAU,CAAC;IACjB,uBAAuB;IACvB,QAAQ,EAAE;QACR,mCAAmC;QACnC,IAAI,EAAE,MAAM,CAAC;QACb,oCAAoC;QACpC,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,2CAA2C;IAC3C,OAAO,EAAE,OAAO,CAAC;IACjB,uCAAuC;IACvC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wCAAwC;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+CAA+C;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,SAAS;IACxB,yBAAyB;IACzB,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,aAAa,GAAG,WAAW,CAAC;IAEzD,gCAAgC;IAChC,OAAO,EAAE,MAAM,CAAC;IAEhB,kCAAkC;IAClC,SAAS,EAAE,IAAI,CAAC;IAEhB,0DAA0D;IAC1D,SAAS,CAAC,EAAE,cAAc,EAAE,CAAC;IAE7B,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,cAAc,CAAC;IAE1B,wDAAwD;IACxD,UAAU,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAEnE,6CAA6C;IAC7C,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB,gDAAgD;IAChD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B,+CAA+C;IAC/C,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAE/B,wCAAwC;IACxC,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,yEAAyE;IACzE,kBAAkB,CAAC,EAAE,IAAI,CAAC;IAE1B,uEAAuE;IACvE,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAC1B,SAAS,GACT,WAAW,GACX,YAAY,GACZ,aAAa,GACb,MAAM,GACN,aAAa,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,cAAc;IAC7B,8BAA8B;IAC9B,IAAI,EAAE,kBAAkB,CAAC;IAEzB,wCAAwC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,6DAA6D;IAC7D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B,kDAAkD;IAClD,SAAS,CAAC,EAAE,cAAc,EAAE,CAAC;IAE7B,uBAAuB;IACvB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAE1B,qDAAqD;IACrD,UAAU,CAAC,EAAE,aAAa,CAAC;IAE3B,2CAA2C;IAC3C,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,uEAAuE;IACvE,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,+BAA+B;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,+CAA+C;IAC/C,UAAU,CAAC,EAAE,cAAc,EAAE,CAAC;IAE9B,kDAAkD;IAClD,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,SAAS,EAAE,CAAC"}

package/dist/public/agent/chat-types.js

@@ -0,0 +1,10 @@
+/**
+ * @ax-cli/schemas - Agent Chat Types
+ *
+ * Single Source of Truth (SSOT) for agent chat-related types.
+ * These types are used across the agent, UI, checkpoint, and SDK modules.
+ *
+ * @packageDocumentation
+ */
+export {};
+//# sourceMappingURL=chat-types.js.map

package/dist/public/agent/chat-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-types.js","sourceRoot":"","sources":["../../../src/public/agent/chat-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/public/agent/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @ax-cli/schemas - Agent Types
+ *
+ * Exports all agent-related types for the ax-cli ecosystem.
+ *
+ * @packageDocumentation
+ */
+export { type LLMToolCallRef, type ToolResultRef, type ChatEntry, type StreamingChunkType, type StreamingChunk, type AccumulatedMessage, type ChatHistory, } from './chat-types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/public/agent/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/public/agent/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,KAAK,WAAW,GACjB,MAAM,iBAAiB,CAAC"}

package/dist/public/agent/index.js

@@ -0,0 +1,9 @@
+/**
+ * @ax-cli/schemas - Agent Types
+ *
+ * Exports all agent-related types for the ax-cli ecosystem.
+ *
+ * @packageDocumentation
+ */
+export {};
+//# sourceMappingURL=index.js.map

package/dist/public/agent/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/public/agent/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}