@makaio/contracts 1.0.0-dev-1779051654000

package/dist/adapter/schemas/infer.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+/**
+ * One-shot inference request/response schema.
+ *
+ * Subject: `adapter.infer`
+ * Type: Request (RPC)
+ * Purpose: Ephemeral LLM inference without agent lifecycle overhead.
+ *          Used for classification, quick prompts, and meta-LLM calls.
+ *
+ * The adapter creates a temporary connector, executes the inference,
+ * extracts the text response, and cleans up — no persistent agent.
+ */
+export declare const InferSchema: {
+    request: z.ZodObject<{
+        adapterId: z.ZodString;
+        prompt: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        providerContext: z.ZodOptional<z.ZodObject<{
+            providerConfigId: z.ZodString;
+            definitionId: z.ZodString;
+            endpointOverrides: z.ZodOptional<z.ZodObject<{
+                anthropic: z.ZodOptional<z.ZodString>;
+                openai: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            credentialRefs: z.ZodRecord<z.ZodString, z.core.$ZodBranded<z.ZodString, "CredentialRef", "out">>;
+            credentialEnvVars: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            ambientCredentialEnvVars: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+        text: z.ZodString;
+        usage: z.ZodOptional<z.ZodObject<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+};
+export type InferRequest = z.infer<typeof InferSchema.request>;
+export type InferResponse = z.infer<typeof InferSchema.response>;
+//# sourceMappingURL=infer.d.ts.map

package/dist/adapter/schemas/infer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer.d.ts","sourceRoot":"","sources":["../../../src/adapter/schemas/infer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;CAgCvB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,OAAO,CAAC,CAAC;AAC/D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,QAAQ,CAAC,CAAC"}

package/dist/adapter/schemas/initialized.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+/**
+ * Adapter initialization completed.
+ *
+ * Subject: `adapter.initialized`
+ * Type: Event (fire-and-forget)
+ * Emitted when: Adapter finishes initialization and is ready to handle requests.
+ *
+ * This event signals that all adapter handlers are registered and the adapter
+ * is ready to process incoming messages. Useful for coordinating startup timing
+ * and preventing race conditions when transports accept connections before
+ * adapters are ready.
+ * @example
+ * ```typescript
+ * bus.on(AdapterSubjects.initialized, (context) => {
+ *   console.debug(`Adapter ${context.payload.adapterName} ready with capabilities:`, context.payload.capabilities);
+ * });
+ * ```
+ */
+export declare const InitializedSchema: z.ZodObject<{
+    adapterId: z.ZodString;
+    adapterName: z.ZodString;
+    capabilities: z.ZodArray<z.ZodString>;
+    nativeTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type Initialized = z.infer<typeof InitializedSchema>;
+//# sourceMappingURL=initialized.d.ts.map

package/dist/adapter/schemas/initialized.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initialized.d.ts","sourceRoot":"","sources":["../../../src/adapter/schemas/initialized.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,iBAAiB;;;;;iBAK5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/adapter/schemas/list-agents.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+/**
+ * List active agents for an adapter.
+ *
+ * Subject: `adapter.listAgents`
+ * Type: Request (RPC)
+ * Purpose: Returns all active agents managed by the specified adapter.
+ */
+export declare const ListAgentsSchema: {
+    request: z.ZodObject<{
+        adapterId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+        agents: z.ZodArray<z.ZodObject<{
+            agentId: z.ZodString;
+            sessionId: z.ZodString;
+            adapterSessionId: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+};
+export type ListAgentsRequest = z.infer<typeof ListAgentsSchema.request>;
+export type ListAgentsResponse = z.infer<typeof ListAgentsSchema.response>;
+//# sourceMappingURL=list-agents.d.ts.map

package/dist/adapter/schemas/list-agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-agents.d.ts","sourceRoot":"","sources":["../../../src/adapter/schemas/list-agents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;CAiB5B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,OAAO,CAAC,CAAC;AACzE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,QAAQ,CAAC,CAAC"}

package/dist/adapter/schemas/log.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+/**
+ * Adapter or SDK log message.
+ *
+ * Subject: `adapter.log`
+ * Type: Event (fire-and-forget)
+ * Emitted when: Adapter or SDK emits log messages (authentication, connection status, etc.)
+ * @example
+ * ```typescript
+ * bus.emit(AdapterSubjects.log, {
+ *   message: 'Authenticated successfully',
+ *   level: 'info',
+ *   timestamp: Date.now(),
+ *   adapterId: 'adapter-123',
+ *   adapterName: 'claude-code'
+ * });
+ * ```
+ */
+export declare const LogSchema: z.ZodObject<{
+    adapterId: z.ZodString;
+    adapterName: z.ZodString;
+    message: z.ZodString;
+    timestamp: z.ZodNumber;
+    level: z.ZodOptional<z.ZodEnum<{
+        debug: "debug";
+        error: "error";
+        info: "info";
+        warn: "warn";
+    }>>;
+}, z.core.$strip>;
+export type Log = z.infer<typeof LogSchema>;
+//# sourceMappingURL=log.d.ts.map

package/dist/adapter/schemas/log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../../src/adapter/schemas/log.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;iBAIpB,CAAC;AAEH,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC"}

package/dist/adapter/schemas/provider-context.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+/**
+ * Unresolved provider context passed on the public bus.
+ *
+ * Carries credential references (not plaintext) so credentials never
+ * travel on the public bus. Connectors call `resolveConnectorCredentials()`
+ * to obtain plaintext locally.
+ */
+export declare const ProviderContextSchema: z.ZodObject<{
+    providerConfigId: z.ZodString;
+    definitionId: z.ZodString;
+    endpointOverrides: z.ZodOptional<z.ZodObject<{
+        anthropic: z.ZodOptional<z.ZodString>;
+        openai: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    credentialRefs: z.ZodRecord<z.ZodString, z.core.$ZodBranded<z.ZodString, "CredentialRef", "out">>;
+    credentialEnvVars: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    ambientCredentialEnvVars: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Inferred type for an unresolved provider context.
+ */
+export type ProviderContext = z.infer<typeof ProviderContextSchema>;
+//# sourceMappingURL=provider-context.d.ts.map

package/dist/adapter/schemas/provider-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-context.d.ts","sourceRoot":"","sources":["../../../src/adapter/schemas/provider-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;iBA2BhC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/adapter/schemas/quota.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+/**
+ * Account-wide quota and billing metrics.
+ *
+ * Subject: `adapter.quota`
+ * Type: Event (fire-and-forget)
+ * Emitted when: Quota information is available from the provider (e.g., GitHub Copilot)
+ *
+ * This tracks account-wide usage limits across all sessions in the billing period.
+ * Only applicable to providers with quota systems (currently GitHub Copilot).
+ */
+export declare const QuotaSchema: z.ZodObject<{
+    adapterId: z.ZodString;
+    adapterName: z.ZodString;
+    provider: z.ZodString;
+    quotaType: z.ZodString;
+    limit: z.ZodNumber;
+    used: z.ZodNumber;
+    overage: z.ZodNumber;
+    resetDate: z.ZodString;
+}, z.core.$strip>;
+export type Quota = z.infer<typeof QuotaSchema>;
+//# sourceMappingURL=quota.d.ts.map

package/dist/adapter/schemas/quota.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quota.d.ts","sourceRoot":"","sources":["../../../src/adapter/schemas/quota.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;;;;;;;;;iBAOtB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC"}

package/dist/adapter/schemas/rehydrate-agent.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+/**
+ * Rehydrate an agent by swapping its connector.
+ *
+ * Subject: `adapter.rehydrateAgent`
+ * Type: Request (RPC)
+ * Purpose: Allows the orchestrator to swap an agent's connector (e.g., after a crash)
+ * instead of killing and recreating the agent. This preserves the agent's
+ * identity and session state while replacing the underlying execution context.
+ *
+ * The adapter will:
+ * 1. Stop the existing connector for the specified agent
+ * 2. Create a new connector with optional config overrides (cwd, model)
+ * 3. Wire the new connector to the existing agent instance
+ *
+ * Success is implicit. Errors are thrown if:
+ * - Agent not found
+ * - Adapter not found
+ * - Connector swap fails
+ * @param adapterId - Target adapter instance ID
+ * @param agentId - Agent to rehydrate
+ * @param cwd - Optional working directory override for new connector
+ * @param model - Optional model override for new connector
+ */
+export declare const RehydrateAgentSchema: {
+    request: z.ZodObject<{
+        adapterId: z.ZodString;
+        agentId: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    /** Empty response - success is implicit, errors throw */
+    response: z.ZodObject<{}, z.core.$strip>;
+};
+export type RehydrateAgentRequest = z.infer<typeof RehydrateAgentSchema.request>;
+export type RehydrateAgentResponse = z.infer<typeof RehydrateAgentSchema.response>;
+//# sourceMappingURL=rehydrate-agent.d.ts.map

package/dist/adapter/schemas/rehydrate-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rehydrate-agent.d.ts","sourceRoot":"","sources":["../../../src/adapter/schemas/rehydrate-agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;IAe/B,yDAAyD;;CAE1D,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,OAAO,CAAC,CAAC;AACjF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,QAAQ,CAAC,CAAC"}

package/dist/adapter/schemas/runtime-options.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+/**
+ * Runtime options for agent execution.
+ *
+ * SEAM: Tool naming is adapter-specific and not yet normalized.
+ * Use `allowedTools`/`disallowedTools` with provider-specific tool names.
+ * @example
+ * ```typescript
+ * // Claude Code adapter
+ * runtimeOptions: {
+ *   cwd: '/path/to/project',
+ *   allowedTools: ['Read', 'WebSearch'],  // Claude Code tool names
+ * }
+ *
+ * // Future: Other adapters will have different tool names
+ * runtimeOptions: {
+ *   allowedTools: ['file_read', 'web_search'],  // Hypothetical OpenAI adapter
+ * }
+ * ```
+ */
+export declare const AdapterRuntimeOptionsSchema: z.ZodObject<{
+    cwd: z.ZodOptional<z.ZodString>;
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disallowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    allowedDirectories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    systemPrompt: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        mode: z.ZodLiteral<"append">;
+        content: z.ZodString;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>;
+export type AdapterRuntimeOptions = z.infer<typeof AdapterRuntimeOptionsSchema>;
+//# sourceMappingURL=runtime-options.d.ts.map

package/dist/adapter/schemas/runtime-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-options.d.ts","sourceRoot":"","sources":["../../../src/adapter/schemas/runtime-options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;iBAkCtC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/adapter/schemas/session-closed.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+/**
+ * External provider session closed.
+ *
+ * Subject: `adapter.session.closed`
+ * Type: Event (fire-and-forget)
+ * Emitted when: SDK session ends
+ *
+ * Re-emitted by AIAdapter when it receives AgentSubjects.session_closed.
+ */
+export declare const SessionClosedSchema: z.ZodObject<{
+    adapterId: z.ZodString;
+    adapterName: z.ZodString;
+    agentId: z.ZodString;
+    sessionId: z.ZodString;
+    adapterSessionId: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SessionClosed = z.infer<typeof SessionClosedSchema>;
+//# sourceMappingURL=session-closed.d.ts.map

package/dist/adapter/schemas/session-closed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-closed.d.ts","sourceRoot":"","sources":["../../../src/adapter/schemas/session-closed.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB;;;;;;;iBAM9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/adapter/schemas/session-created.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+/**
+ * External provider session established.
+ *
+ * Subject: `adapter.session.created`
+ * Type: Event (fire-and-forget)
+ * Emitted when: SDK session is created (Anthropic, OpenAI, etc.)
+ */
+export declare const SessionCreatedSchema: z.ZodObject<{
+    adapterId: z.ZodString;
+    adapterName: z.ZodString;
+    adapterSessionId: z.ZodString;
+    sessionId: z.ZodString;
+    model: z.ZodString;
+}, z.core.$strip>;
+export type SessionCreated = z.infer<typeof SessionCreatedSchema>;
+//# sourceMappingURL=session-created.d.ts.map

package/dist/adapter/schemas/session-created.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-created.d.ts","sourceRoot":"","sources":["../../../src/adapter/schemas/session-created.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB;;;;;;iBAI/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/adapter/schemas/session-discovered.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const SessionDiscoveredSchema: z.ZodIntersection<z.ZodObject<{
+    adapterId: z.ZodString;
+    adapterName: z.ZodString;
+    model: z.ZodNullable<z.ZodString>;
+    cwd: z.ZodNullable<z.ZodString>;
+    adapterSessionId: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    logFilePath: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    startedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"root">;
+    parentAdapterSessionId: z.ZodNull;
+    forkPointMessageId: z.ZodNull;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"fork">;
+    parentAdapterSessionId: z.ZodString;
+    forkPointMessageId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"subagent">;
+    parentAdapterSessionId: z.ZodString;
+    forkPointMessageId: z.ZodNull;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"compress">;
+    parentAdapterSessionId: z.ZodString;
+    forkPointMessageId: z.ZodNull;
+}, z.core.$strip>], "kind">>;
+export type SessionDiscovered = z.infer<typeof SessionDiscoveredSchema>;
+//# sourceMappingURL=session-discovered.d.ts.map

package/dist/adapter/schemas/session-discovered.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-discovered.d.ts","sourceRoot":"","sources":["../../../src/adapter/schemas/session-discovered.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoCxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;4BAA4D,CAAC;AAEjG,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/adapter/schemas/session-lineage.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+/** Closed set of adapter session lineage kinds. */
+export declare const SESSION_LINEAGE_KINDS: readonly ["root", "fork", "subagent", "compress"];
+/** Canonical root lineage literal. */
+export declare const ROOT_SESSION_LINEAGE_KIND: "root";
+/** Canonical fork lineage literal. */
+export declare const FORK_SESSION_LINEAGE_KIND: "fork";
+/** Canonical subagent lineage literal. */
+export declare const SUBAGENT_SESSION_LINEAGE_KIND: "subagent";
+/** Canonical compress lineage literal. */
+export declare const COMPRESS_SESSION_LINEAGE_KIND: "compress";
+/** Discriminates the relationship of a session to its parent. */
+export declare const SessionLineageKindSchema: z.ZodEnum<{
+    compress: "compress";
+    fork: "fork";
+    root: "root";
+    subagent: "subagent";
+}>;
+export type SessionLineageKind = z.infer<typeof SessionLineageKindSchema>;
+/**
+ * Canonical lineage contract for adapter sessions.
+ * Reusable by any adapter with fork/subagent concepts.
+ */
+export declare const RootSessionLineageSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"root">;
+    parentAdapterSessionId: z.ZodNull;
+    forkPointMessageId: z.ZodNull;
+}, z.core.$strip>;
+export declare const ForkSessionLineageSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"fork">;
+    parentAdapterSessionId: z.ZodString;
+    forkPointMessageId: z.ZodString;
+}, z.core.$strip>;
+export declare const SubagentSessionLineageSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"subagent">;
+    parentAdapterSessionId: z.ZodString;
+    forkPointMessageId: z.ZodNull;
+}, z.core.$strip>;
+export declare const CompressSessionLineageSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"compress">;
+    parentAdapterSessionId: z.ZodString;
+    forkPointMessageId: z.ZodNull;
+}, z.core.$strip>;
+export declare const SessionLineageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"root">;
+    parentAdapterSessionId: z.ZodNull;
+    forkPointMessageId: z.ZodNull;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"fork">;
+    parentAdapterSessionId: z.ZodString;
+    forkPointMessageId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"subagent">;
+    parentAdapterSessionId: z.ZodString;
+    forkPointMessageId: z.ZodNull;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"compress">;
+    parentAdapterSessionId: z.ZodString;
+    forkPointMessageId: z.ZodNull;
+}, z.core.$strip>], "kind">;
+export type SessionLineage = z.infer<typeof SessionLineageSchema>;
+//# sourceMappingURL=session-lineage.d.ts.map

package/dist/adapter/schemas/session-lineage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-lineage.d.ts","sourceRoot":"","sources":["../../../src/adapter/schemas/session-lineage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,mDAAmD;AACnD,eAAO,MAAM,qBAAqB,mDAAoD,CAAC;AACvF,sCAAsC;AACtC,eAAO,MAAM,yBAAyB,QAAkB,CAAC;AACzD,sCAAsC;AACtC,eAAO,MAAM,yBAAyB,QAAkB,CAAC;AACzD,0CAA0C;AAC1C,eAAO,MAAM,6BAA6B,YAAsB,CAAC;AACjE,0CAA0C;AAC1C,eAAO,MAAM,6BAA6B,YAAsB,CAAC;AAEjE,iEAAiE;AACjE,eAAO,MAAM,wBAAwB;;;;;EAAgC,CAAC;AACtE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E;;;GAGG;AACH,eAAO,MAAM,wBAAwB;;;;iBAOnC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;iBAOnC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;iBAOvC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;iBAOvC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;2BAK/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/adapter/schemas/session-lineage.mjs

@@ -0,0 +1 @@
+import{z as e}from"zod";const t=[`root`,`fork`,`subagent`,`compress`],n=`root`,r=`fork`,i=`subagent`,a=`compress`,o=e.enum(t),s=e.object({kind:e.literal(n),parentAdapterSessionId:e.null(),forkPointMessageId:e.null()}),c=e.object({kind:e.literal(r),parentAdapterSessionId:e.string(),forkPointMessageId:e.string()}),l=e.object({kind:e.literal(i),parentAdapterSessionId:e.string(),forkPointMessageId:e.null()}),u=e.object({kind:e.literal(a),parentAdapterSessionId:e.string(),forkPointMessageId:e.null()}),d=e.discriminatedUnion(`kind`,[s,c,l,u]);export{a as COMPRESS_SESSION_LINEAGE_KIND,u as CompressSessionLineageSchema,r as FORK_SESSION_LINEAGE_KIND,c as ForkSessionLineageSchema,n as ROOT_SESSION_LINEAGE_KIND,s as RootSessionLineageSchema,t as SESSION_LINEAGE_KINDS,i as SUBAGENT_SESSION_LINEAGE_KIND,o as SessionLineageKindSchema,d as SessionLineageSchema,l as SubagentSessionLineageSchema};

package/dist/adapter/schemas/session-linked.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+/**
+ * Adapter session linked to a Makaio session.
+ *
+ * Subject: `adapter.session.linked`
+ * Type: Event (fire-and-forget)
+ * Emitted when: An imported adapter session is linked to a Makaio session
+ *
+ * Unlike session.discovered (which has no sessionId because the session
+ * doesn't exist yet), this event confirms the linkage has been established.
+ * Used to resolve parent relationships for sessions imported out of order.
+ *
+ * `adapterId` is optional here because linkage can occur during log import
+ * before the owning adapter instance has been configured or started. Consumers
+ * that need a resolved adapterId should use `AdapterRuntimeSubjects.resolveId`
+ * separately through the runtime identity handlers.
+ */
+export declare const SessionLinkedSchema: z.ZodObject<{
+    adapterName: z.ZodString;
+    adapterId: z.ZodOptional<z.ZodString>;
+    adapterSessionId: z.ZodString;
+    sessionId: z.ZodString;
+    replay: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SessionLinked = z.infer<typeof SessionLinkedSchema>;
+//# sourceMappingURL=session-linked.d.ts.map

package/dist/adapter/schemas/session-linked.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-linked.d.ts","sourceRoot":"","sources":["../../../src/adapter/schemas/session-linked.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,mBAAmB;;;;;;iBAY9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/adapter/schemas/session-status-changed.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+/**
+ * Adapter session status changed.
+ *
+ * Subject: `adapter.session.statusChanged`
+ * Type: Event (fire-and-forget)
+ * Emitted when: An adapter session's import status transitions
+ * (e.g., discovered → imported, discovered → tracking).
+ *
+ * Used by the entity cache to keep `adapterSessions` reactive in the UI.
+ * Emitted by the storage layer, so `adapterId` is not available.
+ */
+export declare const SessionStatusChangedSchema: z.ZodObject<{
+    adapterSessionId: z.ZodString;
+    status: z.ZodEnum<{
+        discovered: "discovered";
+        imported: "imported";
+        live: "live";
+        tracking: "tracking";
+    }>;
+}, z.core.$strip>;
+export type SessionStatusChanged = z.infer<typeof SessionStatusChangedSchema>;
+//# sourceMappingURL=session-status-changed.d.ts.map

package/dist/adapter/schemas/session-status-changed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-status-changed.d.ts","sourceRoot":"","sources":["../../../src/adapter/schemas/session-status-changed.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;iBAYrC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

package/dist/adapter/schemas/session-usage.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+/**
+ * Session-level cumulative usage metrics.
+ *
+ * Subject: `adapter.session.usage`
+ * Type: Event (fire-and-forget)
+ * Emitted when: Session usage totals are updated (after each API call)
+ *
+ * This event contains running totals for the entire session/conversation.
+ * For per-call delta metrics, see `agent.usage`.
+ */
+export declare const SessionUsageSchema: z.ZodObject<{
+    adapterId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodString;
+    adapterSessionId: z.ZodString;
+    totalInputTokens: z.ZodNumber;
+    totalOutputTokens: z.ZodNumber;
+    totalCalls: z.ZodNumber;
+}, z.core.$strip>;
+export type SessionUsage = z.infer<typeof SessionUsageSchema>;
+//# sourceMappingURL=session-usage.d.ts.map

package/dist/adapter/schemas/session-usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-usage.d.ts","sourceRoot":"","sources":["../../../src/adapter/schemas/session-usage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;iBAM7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}