@kuralle-agents/core 0.11.0 → 0.13.0

package/dist/tracing/OtelTraceSink.d.ts

@@ -0,0 +1,127 @@
+import type { AgentSpan } from '../types/trace.js';
+import type { TraceSink } from './TraceStore.js';
+export interface OtelTraceSinkOptions {
+    endpoint: string;
+    headers?: Record<string, string>;
+    serviceName?: string;
+    batchSize?: number;
+    fetch?: typeof fetch;
+}
+export declare class OtelTraceSink implements TraceSink {
+    private readonly options;
+    private readonly pending;
+    private exporting?;
+    constructor(options: OtelTraceSinkOptions);
+    write(span: AgentSpan): Promise<void> | void;
+    flush(): Promise<void>;
+    private export;
+}
+export declare function otelSink(options: OtelTraceSinkOptions): OtelTraceSink;
+export interface LangfuseSinkOptions {
+    endpoint?: string;
+    publicKey: string;
+    secretKey: string;
+    serviceName?: string;
+    batchSize?: number;
+    fetch?: typeof fetch;
+}
+export declare function langfuseSink(options: LangfuseSinkOptions): OtelTraceSink;
+export declare function toOtlpPayload(spans: AgentSpan[], serviceName?: string): {
+    resourceSpans: {
+        resource: {
+            attributes: {
+                key: string;
+                value: {
+                    stringValue: string;
+                };
+            }[];
+        };
+        scopeSpans: {
+            scope: {
+                name: string;
+            };
+            spans: {
+                name: string;
+                kind: number;
+                startTimeUnixNano: string;
+                endTimeUnixNano: string;
+                attributes: ({
+                    key: string;
+                    value: {
+                        boolValue: boolean;
+                        intValue?: undefined;
+                        doubleValue?: undefined;
+                        stringValue?: undefined;
+                    };
+                } | {
+                    key: string;
+                    value: {
+                        intValue: string;
+                        boolValue?: undefined;
+                        doubleValue?: undefined;
+                        stringValue?: undefined;
+                    };
+                } | {
+                    key: string;
+                    value: {
+                        doubleValue: number;
+                        boolValue?: undefined;
+                        intValue?: undefined;
+                        stringValue?: undefined;
+                    };
+                } | {
+                    key: string;
+                    value: {
+                        stringValue: string;
+                        boolValue?: undefined;
+                        intValue?: undefined;
+                        doubleValue?: undefined;
+                    };
+                })[];
+                events: {
+                    name: string;
+                    timeUnixNano: string;
+                    attributes: ({
+                        key: string;
+                        value: {
+                            boolValue: boolean;
+                            intValue?: undefined;
+                            doubleValue?: undefined;
+                            stringValue?: undefined;
+                        };
+                    } | {
+                        key: string;
+                        value: {
+                            intValue: string;
+                            boolValue?: undefined;
+                            doubleValue?: undefined;
+                            stringValue?: undefined;
+                        };
+                    } | {
+                        key: string;
+                        value: {
+                            doubleValue: number;
+                            boolValue?: undefined;
+                            intValue?: undefined;
+                            stringValue?: undefined;
+                        };
+                    } | {
+                        key: string;
+                        value: {
+                            stringValue: string;
+                            boolValue?: undefined;
+                            intValue?: undefined;
+                            doubleValue?: undefined;
+                        };
+                    })[];
+                }[];
+                status: {
+                    code: number;
+                };
+                parentSpanId?: string | undefined;
+                traceId: string;
+                spanId: string;
+            }[];
+        }[];
+    }[];
+};

package/dist/tracing/OtelTraceSink.js

@@ -0,0 +1,101 @@
+export class OtelTraceSink {
+    options;
+    pending = [];
+    exporting;
+    constructor(options) {
+        this.options = options;
+    }
+    write(span) {
+        this.pending.push(structuredClone(span));
+        if (this.pending.length >= (this.options.batchSize ?? 32))
+            return this.flush();
+    }
+    async flush() {
+        if (this.exporting)
+            await this.exporting;
+        if (this.pending.length === 0)
+            return;
+        const spans = this.pending.splice(0);
+        this.exporting = this.export(spans).finally(() => { this.exporting = undefined; });
+        await this.exporting;
+    }
+    async export(spans) {
+        const transport = this.options.fetch ?? globalThis.fetch;
+        const response = await transport(otlpUrl(this.options.endpoint), {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', ...this.options.headers },
+            body: JSON.stringify(toOtlpPayload(spans, this.options.serviceName)),
+        });
+        if (!response.ok)
+            throw new Error(`OTLP trace export failed: ${response.status}`);
+    }
+}
+export function otelSink(options) {
+    return new OtelTraceSink(options);
+}
+export function langfuseSink(options) {
+    return new OtelTraceSink({
+        endpoint: options.endpoint ?? 'https://cloud.langfuse.com/api/public/otel',
+        headers: {
+            Authorization: `Basic ${btoa(`${options.publicKey}:${options.secretKey}`)}`,
+            'x-langfuse-ingestion-version': '4',
+        },
+        serviceName: options.serviceName,
+        batchSize: options.batchSize,
+        fetch: options.fetch,
+    });
+}
+export function toOtlpPayload(spans, serviceName = 'kuralle-agent') {
+    return {
+        resourceSpans: [{
+                resource: { attributes: [{ key: 'service.name', value: { stringValue: serviceName } }] },
+                scopeSpans: [{
+                        scope: { name: '@kuralle-agents/core' },
+                        spans: spans.map(toOtlpSpan),
+                    }],
+            }],
+    };
+}
+function toOtlpSpan(span) {
+    return {
+        traceId: normalizeHex(span.traceId, 32),
+        spanId: normalizeHex(span.spanId, 16),
+        ...(span.parentSpanId ? { parentSpanId: normalizeHex(span.parentSpanId, 16) } : {}),
+        name: span.name,
+        kind: 1,
+        startTimeUnixNano: millisecondsToNanos(span.startTime),
+        endTimeUnixNano: millisecondsToNanos(span.endTime ?? span.startTime),
+        attributes: [
+            otlpAttribute('kuralle.kind', span.kind),
+            ...Object.entries(span.attributes)
+                .filter(([, value]) => value !== undefined)
+                .map(([key, value]) => otlpAttribute(`kuralle.${key}`, value)),
+        ],
+        events: (span.events ?? []).map((event) => ({
+            name: event.name,
+            timeUnixNano: millisecondsToNanos(event.time),
+            attributes: Object.entries(event.attributes ?? {}).map(([key, value]) => otlpAttribute(`kuralle.${key}`, value)),
+        })),
+        status: { code: span.status === 'error' ? 2 : 1 },
+    };
+}
+function otlpAttribute(key, value) {
+    if (typeof value === 'boolean')
+        return { key, value: { boolValue: value } };
+    if (typeof value === 'number' && Number.isInteger(value))
+        return { key, value: { intValue: String(value) } };
+    if (typeof value === 'number')
+        return { key, value: { doubleValue: value } };
+    return { key, value: { stringValue: typeof value === 'string' ? value : JSON.stringify(value) } };
+}
+function normalizeHex(value, length) {
+    const hex = value.toLowerCase().replace(/[^0-9a-f]/g, '');
+    return hex.padStart(length, '0').slice(-length);
+}
+function millisecondsToNanos(value) {
+    return (BigInt(Math.trunc(value)) * 1000000n).toString();
+}
+function otlpUrl(endpoint) {
+    const trimmed = endpoint.replace(/\/$/, '');
+    return trimmed.endsWith('/v1/traces') ? trimmed : `${trimmed}/v1/traces`;
+}

package/dist/tracing/TraceStore.d.ts

@@ -0,0 +1,19 @@
+import type { AgentSpan, AgentTrace } from '../types/trace.js';
+export interface TraceListWindow {
+    from?: Date;
+    to?: Date;
+    limit?: number;
+}
+export interface TraceSink {
+    write(span: AgentSpan): void | Promise<void>;
+    flush?(): Promise<void>;
+}
+export interface TraceStore extends TraceSink {
+    putSpan(span: AgentSpan): void | Promise<void>;
+    getTrace(traceId: string): Promise<AgentTrace | null>;
+    listTraces(sessionId: string, window?: TraceListWindow): Promise<AgentTrace[]>;
+    cleanup?(maxAgeMs: number): Promise<number>;
+}
+export declare function isTraceStore(sink: TraceSink): sink is TraceStore;
+export declare function traceFromSpans(spans: AgentSpan[]): AgentTrace | null;
+export declare function cloneSpan(span: AgentSpan): AgentSpan;

package/dist/tracing/TraceStore.js

@@ -0,0 +1,32 @@
+export function isTraceStore(sink) {
+    const value = sink;
+    return typeof value.putSpan === 'function' &&
+        typeof value.getTrace === 'function' &&
+        typeof value.listTraces === 'function';
+}
+export function traceFromSpans(spans) {
+    if (spans.length === 0)
+        return null;
+    const ordered = spans.map(cloneSpan).sort((a, b) => a.startTime - b.startTime);
+    const root = ordered.find((span) => span.kind === 'turn') ?? ordered[0];
+    const tools = ordered.filter((span) => span.kind === 'tool');
+    return {
+        traceId: root.traceId,
+        sessionId: root.attributes.sessionId,
+        spans: ordered,
+        answer: typeof root.attributes.output === 'string' ? root.attributes.output : '',
+        usedTool: tools.length > 0,
+        toolCalls: tools.map((span) => ({
+            name: span.attributes.toolName ?? span.name,
+            args: span.attributes.input ?? null,
+        })),
+        toolResults: tools
+            .filter((span) => span.attributes.output !== undefined)
+            .map((span) => ({ name: span.attributes.toolName ?? span.name, result: span.attributes.output })),
+        startedAt: root.startTime,
+        ...(root.endTime !== undefined ? { endedAt: root.endTime } : {}),
+    };
+}
+export function cloneSpan(span) {
+    return structuredClone(span);
+}

package/dist/tracing/index.d.ts

@@ -0,0 +1,3 @@
+export { MemoryTraceStore, type MemoryTraceStoreOptions } from './MemoryTraceStore.js';
+export { isTraceStore, traceFromSpans, type TraceListWindow, type TraceSink, type TraceStore, } from './TraceStore.js';
+export { OtelTraceSink, langfuseSink, otelSink, toOtlpPayload, type LangfuseSinkOptions, type OtelTraceSinkOptions, } from './OtelTraceSink.js';

package/dist/tracing/index.js

@@ -0,0 +1,3 @@
+export { MemoryTraceStore } from './MemoryTraceStore.js';
+export { isTraceStore, traceFromSpans, } from './TraceStore.js';
+export { OtelTraceSink, langfuseSink, otelSink, toOtlpPayload, } from './OtelTraceSink.js';

package/dist/tracing/testing.d.ts

@@ -0,0 +1,3 @@
+import type { TraceStore } from './TraceStore.js';
+export type TraceStoreFactory = () => TraceStore | Promise<TraceStore>;
+export declare function runTraceStoreContract(factory: TraceStoreFactory): void;

package/dist/tracing/testing.js

@@ -0,0 +1,45 @@
+/// <reference types="bun-types" />
+import { beforeEach, describe, expect, test } from 'bun:test';
+export function runTraceStoreContract(factory) {
+    describe('TraceStore contract', () => {
+        let store;
+        beforeEach(async () => { store = await factory(); });
+        test('writes spans and reconstructs a JSON-safe trace', async () => {
+            await store.putSpan(span('trace-a', 'session-a', 'root', 10, 'turn'));
+            await store.putSpan(span('trace-a', 'session-a', 'tool', 11, 'tool'));
+            const trace = await store.getTrace('trace-a');
+            expect(trace?.spans.map((entry) => entry.spanId)).toEqual(['root', 'tool']);
+            expect(trace?.sessionId).toBe('session-a');
+            expect(() => JSON.stringify(trace)).not.toThrow();
+        });
+        test('returns null for a missing trace', async () => {
+            expect(await store.getTrace('missing')).toBeNull();
+        });
+        test('lists newest traces for only the requested session and window', async () => {
+            await store.putSpan(span('old', 'session-a', 'old-root', 10, 'turn'));
+            await store.putSpan(span('new', 'session-a', 'new-root', 30, 'turn'));
+            await store.putSpan(span('other', 'session-b', 'other-root', 40, 'turn'));
+            const traces = await store.listTraces('session-a', { from: new Date(20), limit: 1 });
+            expect(traces.map((trace) => trace.traceId)).toEqual(['new']);
+        });
+        test('upserts a span by trace and span id', async () => {
+            const root = span('trace-a', 'session-a', 'root', 10, 'turn');
+            await store.write(root);
+            await store.putSpan({ ...root, endTime: 25 });
+            expect((await store.getTrace('trace-a'))?.spans).toHaveLength(1);
+            expect((await store.getTrace('trace-a'))?.endedAt).toBe(25);
+        });
+    });
+}
+function span(traceId, sessionId, spanId, startTime, kind) {
+    return {
+        traceId,
+        spanId,
+        name: kind,
+        kind,
+        startTime,
+        endTime: startTime + 5,
+        status: 'ok',
+        attributes: { sessionId },
+    };
+}

package/dist/types/agentConfig.d.ts

@@ -8,9 +8,11 @@ import type { RefinementCapability } from '../capabilities/RefinementCapability.
 import type { ValidationCapability } from '../capabilities/ValidationCapability.js';
 import type { AnyTool } from './effectTool.js';
 import type { FileSystem } from './filesystem.js';
+import type { Shell } from './shell.js';
 import type { SkillSource } from './skills.js';
 export type AgentWorkspaceConfig = FileSystem | {
     fs: FileSystem;
+    shell?: Shell;
     readOnly?: boolean;
 };
 export type Instructions = string | AgentPrompt | ((ctx: {
@@ -48,7 +50,8 @@ export interface AgentConfig {
     /** Pre-turn refinement policies. Default: none. */
     refine?: RefinementCapability[];
     experimental?: {
-        /** Flow reply nodes: silo flow-transition control tools + deterministic evaluator (ADR 0003 H1). Default OFF. */
+        /** Flow reply nodes: silo flow-transition control tools + deterministic evaluator (ADR 0003 H1).
+         *  Default ON when the agent declares `flows`; OFF for answering-only agents. Override explicitly to opt out. */
         outOfBandControl?: boolean;
     };
     /** Portable workspace filesystem; auto-registers the durable `workspace` tool when set.

package/dist/types/channel.d.ts

@@ -1,4 +1,4 @@
-import type { ToolSet } from 'ai';
+import type { ModelMessage, ToolSet } from 'ai';
 import type { UserInputContent } from '../runtime/userInput.js';
 import type { RunContext } from './run-context.js';
 import type { FlowNode } from './flow.js';
@@ -34,6 +34,14 @@ export interface ChannelDriver {
      *  back to runAgentTurn, whose text the engine then discards. */
     runExtraction?(node: ResolvedNode, ctx: RunContext): Promise<TurnResult>;
 }
+export interface TurnUsageSnapshot {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cacheReadTokens?: number;
+    /** Input tokens on the final model call, i.e. current context-window occupancy. */
+    contextTokens?: number;
+}
 export interface TurnResult {
     text: string;
     toolResults: ToolResultRecord[];
@@ -43,6 +51,11 @@ export interface TurnResult {
     confidence?: number;
     /** Native realtime post-hoc gate: provider audio already played; gate is advisory only. */
     gateScope?: 'advisory';
+    /** AI-SDK tool round-trip messages (assistant tool-call + tool-result) produced this turn,
+     *  so the host loop can persist them to history in free conversation (G18). */
+    toolMessages?: ModelMessage[];
+    /** Real token usage from the AI SDK when the driver captured it. */
+    usage?: TurnUsageSnapshot;
 }
 export type UserSignal = {
     type: 'message';

package/dist/types/effectTool.d.ts

@@ -10,6 +10,12 @@ export interface Tool<TInput = unknown, TOutput = unknown> {
     interim?: string;
     interimAfterMs?: number;
     timeoutMs?: number;
+    /** When false, the durable journal always re-executes this tool instead of returning a cached step result — for observation/mutation tools (fs, shell) whose result must be fresh. Default true. */
+    replay?: boolean;
+    /** When true, the tool may run concurrently with other parallel-safe tools in the same model turn. */
+    parallelSafe?: boolean;
+    /** Override the auto-derived effect key (`idempotencyKey(logicalRunId, callsite, {name,args})`). Use when args are not a stable identity (e.g. a nonce). */
+    idempotencyKey?: (args: TInput) => string;
     execute: (args: TInput, ctx?: ToolContext) => Promise<TOutput> | AsyncIterable<TOutput>;
 }
 export type AnyTool = Tool<any, any>;

package/dist/types/index.d.ts

@@ -10,6 +10,7 @@ export * from './tool.js';
 export * from './effectTool.js';
 export * from './voice.js';
 export * from './runtime.js';
+export * from './trace.js';
 export type * from '../audit/types.js';
 export type * from '../outcomes/index.js';
 export type * from '../channels/index.js';

package/dist/types/index.js

@@ -10,3 +10,4 @@ export * from './tool.js';
 export * from './effectTool.js';
 export * from './voice.js';
 export * from './runtime.js';
+export * from './trace.js';

package/dist/types/run-context.d.ts

@@ -10,7 +10,7 @@ import type { Limits } from './guardrails.js';
 import type { AnyTool } from './effectTool.js';
 import type { FileSystem } from './filesystem.js';
 import type { Instructions } from './agentConfig.js';
-import type { AgentKnowledgeOverrides, SourceRef } from './voice.js';
+import type { AgentKnowledgeOverrides, SourceRef, RetrievalCacheAdapter } from './voice.js';
 export interface GatherScope {
     query?: string;
     knowledge?: AgentKnowledgeOverrides & {
@@ -80,6 +80,13 @@ export interface RunContext {
     turnInputConsumed?: boolean;
     /** Citations from the latest gather-phase retrieval on this turn. */
     lastRetrievalCitations?: SourceRef[];
+    /**
+     * Session retrieval cache (G6): created once per run by the KnowledgeProvider,
+     * persists across in-session agent handoffs (this RunContext survives the
+     * handoff branch). Keyed by query embedding; RAG-only, undefined without a
+     * configured knowledge provider + embedder.
+     */
+    retrievalCache?: RetrievalCacheAdapter;
     /** Agent base layer (ADR 0001), set when entering a flow. `baseInstructions`
      *  is composed as a prefix into every node turn's system prompt (persona /
      *  safety / grounding floor); `globalTools` are safe tools made model-visible
@@ -98,6 +105,10 @@ export interface RunContext {
         toolCallId?: string;
         def?: AnyTool;
         toolCtx?: ToolContext;
+        /** Pre-reserved callsite ordinal for parallel-safe tool batches (G9). */
+        callsite?: string;
+        /** Pre-reserved journal index for parallel-safe tool batches (G9). */
+        index?: number;
     }): Promise<unknown>;
     approve(req: {
         title: string;
@@ -116,7 +127,9 @@ export interface RunContext {
      *  a flow's durable callsites are anchored to the flow — identical on fresh entry
      *  (after an answering turn) and on resume (where that turn does not re-run). */
     resetCallsites(): void;
+    /** Reserve N contiguous effect callsite ordinals for parallel-safe tool batches (G9). */
+    reserveCallsites(count: number): string[];
 }
 export type ActionContext = Pick<RunContext, 'tool' | 'approve' | 'signal' | 'now' | 'uuid' | 'emit' | 'fs'>;
-export type ToolContext = Pick<RunContext, 'session' | 'runState' | 'tool' | 'now' | 'uuid' | 'emit' | 'fs'>;
+export type ToolContext = Pick<RunContext, 'session' | 'runState' | 'tool' | 'now' | 'uuid' | 'emit' | 'fs' | 'abortSignal'>;
 export type { ModelMessage };

package/dist/types/session.d.ts

@@ -6,6 +6,14 @@ import type { ConversationOutcomeRecord, CsatRecord } from '../outcomes/types.js
 import type { PersonaExperimentMetadata } from '../persona/types.js';
 import type { ConversationAuditEntry } from '../audit/types.js';
 export type ChannelId = 'web' | 'email' | 'sms' | 'voice' | 'api' | 'slack' | 'discord' | (string & {});
+/** Structured goal/thread entry on session.workingMemory.__goals (G5). */
+export type GoalStatus = 'open' | 'resolved';
+export interface TrackedGoal {
+    topic: string;
+    status: GoalStatus;
+    lastTurn: number;
+    note?: string;
+}
 export interface WorkingMemory {
     get<T>(key: string): T | undefined;
     set<T>(key: string, value: T): void;
@@ -42,6 +50,8 @@ export interface Session {
     pendingRefinement?: RefinementStageResult;
     /** @internal Pending key-facts extraction promises. Awaited before session save. */
     __pendingExtractions?: Promise<void>[];
+    /** Optimistic-concurrency version; must match the stored row on save (C2 CAS). */
+    version?: number;
 }
 export interface SessionMetadata {
     createdAt: Date;

package/dist/types/shell.d.ts

@@ -0,0 +1,15 @@
+export interface ShellResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export interface ShellExecOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export interface Shell {
+    exec(command: string, options?: ShellExecOptions): Promise<ShellResult>;
+    cwd?: string;
+}

package/dist/types/shell.js

@@ -0,0 +1 @@
+export {};

package/dist/types/stream.d.ts

@@ -116,6 +116,14 @@ export type HarnessStreamPart = {
 } | {
     type: 'done';
     sessionId: string;
+    /** Per-turn token usage: `inputTokens`/`outputTokens` are THIS turn's
+     *  consumption (deltas, for cost attribution); `contextTokens` is the current
+     *  context-window occupancy (last prompt tokens, a snapshot). */
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        contextTokens?: number;
+    };
 };
 export interface TurnHandle extends Promise<import('./channel.js').TurnResult> {
     readonly events: AsyncIterable<HarnessStreamPart>;

package/dist/types/trace.d.ts

@@ -0,0 +1,50 @@
+export type SpanKind = 'turn' | 'flow' | 'node' | 'tool' | 'handoff' | 'llm';
+export interface AgentSpan {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    kind: SpanKind;
+    startTime: number;
+    endTime?: number;
+    status: 'ok' | 'error';
+    events?: Array<{
+        name: string;
+        time: number;
+        attributes?: Record<string, unknown>;
+    }>;
+    attributes: {
+        sessionId: string;
+        activeFlow?: string;
+        nodeId?: string;
+        toolName?: string;
+        handoffFrom?: string;
+        handoffTo?: string;
+        input?: unknown;
+        output?: unknown;
+        error?: string;
+        /** Input tokens consumed by this turn (delta — for cost attribution). */
+        tokensIn?: number;
+        /** Output tokens generated by this turn (delta — for cost attribution). */
+        tokensOut?: number;
+        /** Context-window occupancy at this turn (last prompt tokens — a snapshot, not a delta). */
+        contextTokens?: number;
+    };
+}
+export interface AgentTrace {
+    traceId: string;
+    sessionId: string;
+    spans: AgentSpan[];
+    answer: string;
+    usedTool: boolean;
+    toolCalls: Array<{
+        name: string;
+        args: unknown;
+    }>;
+    toolResults: Array<{
+        name: string;
+        result: unknown;
+    }>;
+    startedAt: number;
+    endedAt?: number;
+}

package/dist/types/trace.js

@@ -0,0 +1 @@
+export {};

package/guides/EXAMPLE_VERIFICATION.md

@@ -8,8 +8,8 @@ This verification was run after runtime policy-profile changes to check for regr
 
 Covered suites:
 
-1. `packages/kuralle-core/examples/agents` (Line parity set)
-2. `packages/kuralle-core/examples/flows` (Pipecat parity set)
+1. `packages/core/examples/agents` (Line parity set)
+2. `packages/core/examples/flows` (Pipecat parity set)
 3. Extended package examples (`kuralle-tools`, `kuralle-redis-store`)
 
 ## Results
@@ -30,8 +30,8 @@ Interpretation:
 
 Non-pass items:
 
-1. `packages/kuralle-redis-store/examples/local-redis/test.ts` -> `SKIPPED`
-2. `packages/kuralle-redis-store/examples/local-redis/multi-turn.ts` -> `SKIPPED`
+1. `packages/redis-store/examples/local-redis/test.ts` -> `SKIPPED`
+2. `packages/redis-store/examples/local-redis/multi-turn.ts` -> `SKIPPED`
    - Cause: local Redis was not started.
 
 ## Verdict

package/package.json

@@ -4,9 +4,9 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/kuralle/kuralle-agents.git",
-    "directory": "packages/kuralle-core"
+    "directory": "packages/core"
   },
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "A framework for structured conversational AI agents",
   "publishConfig": {
     "access": "public"
@@ -48,6 +48,14 @@
       "types": "./dist/session/testing.d.ts",
       "default": "./dist/session/testing.js"
     },
+    "./tracing": {
+      "types": "./dist/tracing/index.d.ts",
+      "default": "./dist/tracing/index.js"
+    },
+    "./tracing/testing": {
+      "types": "./dist/tracing/testing.d.ts",
+      "default": "./dist/tracing/testing.js"
+    },
     "./testing": {
       "types": "./dist/testing/index.d.ts",
       "default": "./dist/testing/index.js"
@@ -94,8 +102,8 @@
     "zod": "^4.0.0"
   },
   "devDependencies": {
-    "@cloudflare/vitest-pool-workers": "^0.12.7",
     "@ai-sdk/openai": "^3.0.0",
+    "@cloudflare/vitest-pool-workers": "^0.12.7",
     "@types/node": "^20.11.0",
     "ai": "^6.0.0",
     "bun-types": "^1.3.0",
@@ -103,7 +111,8 @@
     "typescript": "^5.3.0",
     "vitest": "^3.2.4",
     "zod": "^4.0.0",
-    "@kuralle-agents/realtime-audio": "0.11.0"
+    "@kuralle-agents/fs": "0.13.0",
+    "@kuralle-agents/realtime-audio": "0.13.0"
   },
   "dependencies": {
     "chrono-node": "^2.6.0"
@@ -111,6 +120,7 @@
   "scripts": {
     "prebuild": "rm -rf dist",
     "build": "tsc -p tsconfig.json",
+    "typecheck:audit": "tsc --noEmit -p tsconfig.audit.json",
     "typecheck:examples": "tsc --noEmit -p tsconfig.examples.json",
     "clean": "rm -rf dist",
     "test": "bun test ./test && vitest run --config vitest.config.ts",