@blyp/core 0.1.2 → 0.1.22

package/dist/ai/shared/fetch.d.ts

@@ -0,0 +1,5 @@
+import type { BlypProviderOptions } from './types';
+export type BlypFetchOptions = Pick<BlypProviderOptions, 'logger' | 'metadata' | 'limits' | 'exclude'> & {
+    inspectJsonBody?: boolean;
+};
+export declare function blypFetch(fetchImpl: typeof fetch, options?: BlypFetchOptions): typeof fetch;

package/dist/ai/shared/index.d.ts

@@ -0,0 +1,2 @@
+export { blypFetch } from './fetch';
+export type { AIToolCallRecord, BlypAIProvider, BlypAISDK, BlypCaptureOptions, BlypExcludeOptions, BlypLimitOptions, BlypLLMEventPart, BlypLLMTrace, BlypProviderOptions, BlypSDKContext, BlypTraceEvent, } from './types';

package/dist/ai/shared/normalize.d.ts

@@ -0,0 +1,17 @@
+import type { AIToolCallRecord } from './types';
+export type BlypNormalizedUsage = {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    reasoningTokens?: number;
+    cachedInputTokens?: number;
+};
+export declare function normalizeTokenUsage(usage?: Partial<BlypNormalizedUsage>): BlypNormalizedUsage | undefined;
+export declare function normalizeFinishReason(value: unknown): string | undefined;
+export declare function safeJsonParse(value: unknown): unknown;
+export declare function toToolEventData(toolCall: AIToolCallRecord): Record<string, unknown>;
+export declare function safeErrorSummary(error: unknown): {
+    errorType?: string;
+    errorCode?: string | number;
+};
+export declare function toProviderPayload(value: unknown): unknown;

package/dist/ai/shared/redaction.d.ts

@@ -0,0 +1,6 @@
+export declare function toLoggableValue(value: unknown, seen?: WeakSet<object>): unknown;
+export declare function omitPaths(value: Record<string, unknown>, paths: string[]): Record<string, unknown>;
+export declare function truncateValue(value: unknown, maxBytes: number): {
+    value: unknown;
+    truncated: boolean;
+};

package/dist/ai/shared/stream.d.ts

@@ -0,0 +1,7 @@
+export type AsyncIterableLike<T> = AsyncIterable<T> | AsyncIterator<T>;
+export declare function isAsyncIterable<T = unknown>(value: unknown): value is AsyncIterable<T>;
+export declare function wrapAsyncIterable<T>(iterable: AsyncIterable<T>, options: {
+    onChunk?: (chunk: T) => void | Promise<void>;
+    onReturn?: () => void | Promise<void>;
+    onError?: (error: unknown) => void | Promise<void>;
+}): AsyncIterable<T>;

package/dist/ai/shared/trace.d.ts

@@ -0,0 +1,116 @@
+import type { LanguageModelV3CallOptions, LanguageModelV3GenerateResult, LanguageModelV3StreamPart, LanguageModelV3 } from '@ai-sdk/provider';
+import type { BlypLogger } from '../../core/logger';
+import type { AIToolCallRecord, BlypAIProvider, BlypAISDK, BlypProviderOptions, BlypSDKContext, BlypMiddlewareContext, BlypModelOptions, BlypResolvedModelOptions, BlypTraceEvent } from './types';
+type MutableTrace = {
+    traceId: string;
+    provider: string;
+    model: string;
+    callType: 'generate' | 'stream';
+    logger: BlypLogger;
+    params: LanguageModelV3CallOptions;
+    options: BlypResolvedModelOptions;
+    operation: string;
+    metadata: Record<string, unknown>;
+    startedAt: string;
+    startedAtMs: number;
+    firstChunkAtMs?: number;
+    finishReason?: string;
+    usage?: BlypMiddlewareContext['usage'];
+    outputText?: string;
+    streamedText?: string;
+    reasoningText?: string;
+    toolCalls: AIToolCallRecord[];
+    toolCallMap: Map<string, AIToolCallRecord>;
+    events: BlypTraceEvent[];
+    streamChunks: unknown[];
+    truncated: boolean;
+    error?: unknown;
+    capture: Required<BlypResolvedModelOptions['capture']>;
+    input?: unknown;
+    output?: unknown;
+    reasoning?: unknown;
+};
+export declare function resolveBlypModelOptions(options?: BlypModelOptions): BlypResolvedModelOptions;
+type MutableSDKTrace = {
+    traceId: string;
+    provider: BlypAIProvider;
+    sdk: Exclude<BlypAISDK, 'ai-sdk'>;
+    operation: string;
+    method: string;
+    model: string;
+    logger: BlypLogger;
+    metadata: Record<string, unknown>;
+    request: unknown;
+    response?: unknown;
+    usage?: BlypSDKContext['usage'];
+    finishReason?: string;
+    input?: unknown;
+    output?: unknown;
+    toolCalls: AIToolCallRecord[];
+    events: BlypTraceEvent[];
+    error?: unknown;
+    startedAt: string;
+    endedAt?: string;
+    startedAtMs: number;
+    firstChunkAt?: string;
+    firstChunkAtMs?: number;
+    options: BlypResolvedModelOptions;
+    capture: Required<BlypResolvedModelOptions['capture']>;
+    streamed: boolean;
+    rawProviderPayload?: unknown;
+    emitted?: boolean;
+    truncated: boolean;
+};
+export declare function resolveBlypProviderOptions(options?: BlypProviderOptions): BlypResolvedModelOptions;
+export declare function createSDKTraceState(options: {
+    provider: BlypAIProvider;
+    sdk: Exclude<BlypAISDK, 'ai-sdk'>;
+    operation?: string;
+    method: string;
+    model: string;
+    request: unknown;
+    streamed: boolean;
+    config: BlypResolvedModelOptions;
+}): {
+    state: MutableSDKTrace;
+    context: BlypSDKContext;
+};
+export declare function recordSDKUsage(state: MutableSDKTrace, usage?: Partial<NonNullable<BlypSDKContext['usage']>>): void;
+export declare function recordSDKFinishReason(state: MutableSDKTrace, reason: unknown): void;
+export declare function setSDKResponse(state: MutableSDKTrace, response: unknown): void;
+export declare function setSDKInput(state: MutableSDKTrace, input: unknown): void;
+export declare function setSDKOutput(state: MutableSDKTrace, output: unknown): void;
+export declare function setSDKRawProviderPayload(state: MutableSDKTrace, payload: unknown): void;
+export declare function markSDKFirstChunk(state: MutableSDKTrace, context: BlypSDKContext): Promise<void>;
+export declare function addSDKChunkEvent(state: MutableSDKTrace, context: BlypSDKContext, data: Record<string, unknown>): Promise<void>;
+export declare function upsertSDKToolCall(state: MutableSDKTrace, toolCall: AIToolCallRecord): void;
+export declare function emitSDKToolStart(state: MutableSDKTrace, context: BlypSDKContext, toolCall: AIToolCallRecord): Promise<void>;
+export declare function emitSDKToolResult(state: MutableSDKTrace, context: BlypSDKContext, toolCall: AIToolCallRecord): Promise<void>;
+export declare function finalizeSDKTrace(state: MutableSDKTrace, context: BlypSDKContext, options?: {
+    error?: unknown;
+}): Promise<void>;
+export declare function createTraceState(options: {
+    model: LanguageModelV3;
+    params: LanguageModelV3CallOptions;
+    callType: 'generate' | 'stream';
+    config: BlypResolvedModelOptions;
+}): {
+    state: MutableTrace;
+    context: BlypMiddlewareContext;
+};
+export declare function runHookSafely(hook: ((...args: any[]) => void | Promise<void>) | undefined, args: unknown[]): Promise<void>;
+export declare function addTraceEvent(state: MutableTrace, context: BlypMiddlewareContext, event: Omit<BlypTraceEvent, 'timestamp'> & {
+    timestamp?: string;
+}): Promise<void>;
+export declare function captureValue(value: unknown, maxContentBytes: number): {
+    value: unknown;
+    truncated: boolean;
+};
+export declare function sanitizeInput(params: LanguageModelV3CallOptions, state: MutableTrace): unknown;
+export declare function recordGenerateResult(state: MutableTrace, result: LanguageModelV3GenerateResult): void;
+export declare function upsertToolCall(state: MutableTrace, toolCall: AIToolCallRecord): void;
+export declare function consumeStreamPart(state: MutableTrace, context: BlypMiddlewareContext, part: LanguageModelV3StreamPart): Promise<void>;
+export declare function finalizeTrace(state: MutableTrace, context: BlypMiddlewareContext, options?: {
+    error?: unknown;
+}): Promise<void>;
+export {};

package/dist/ai/shared/types.d.ts

@@ -0,0 +1,161 @@
+import type { LanguageModelMiddleware } from 'ai';
+import type { LanguageModelV3 } from '@ai-sdk/provider';
+import type { BlypLogger } from '../../core/logger';
+export type BlypAIProvider = 'openai' | 'anthropic' | 'openrouter';
+export type BlypAISDK = 'ai-sdk' | 'openai-sdk' | 'anthropic-sdk';
+export type BlypTraceEvent = {
+    type: 'ai.start' | 'ai.first_chunk' | 'ai.chunk' | 'ai.tool_call.start' | 'ai.tool_call.result' | 'ai.finish' | 'ai.error';
+    timestamp: string;
+    data?: Record<string, unknown>;
+};
+export type AIToolCallRecord = {
+    id?: string;
+    name: string;
+    input?: unknown;
+    output?: unknown;
+    providerFormat?: unknown;
+    startedAt?: string;
+    finishedAt?: string;
+    durationMs?: number;
+    status: 'started' | 'completed' | 'failed';
+    error?: unknown;
+};
+export type BlypCaptureOptions = {
+    input?: boolean;
+    output?: boolean;
+    toolInputs?: boolean;
+    toolOutputs?: boolean;
+    reasoning?: boolean;
+    streamEvents?: boolean;
+    streamChunks?: boolean;
+    rawProviderPayload?: boolean;
+};
+export type BlypExcludeOptions = {
+    providerOptions?: boolean;
+    requestPaths?: string[];
+    responsePaths?: string[];
+    metadataPaths?: string[];
+    toolNames?: string[];
+};
+export type BlypLimitOptions = {
+    maxContentBytes?: number;
+    maxEvents?: number;
+    maxToolCalls?: number;
+};
+export type BlypMiddlewareContext = {
+    traceId: string;
+    operation: string;
+    provider: string;
+    model: string;
+    callType: 'generate' | 'stream';
+    logger: BlypLogger;
+    params: unknown;
+    metadata: Record<string, unknown>;
+    startedAt: string;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+        reasoningTokens?: number;
+        cachedInputTokens?: number;
+    };
+    finishReason?: string;
+    streamedText?: string;
+    outputText?: string;
+    toolCalls?: AIToolCallRecord[];
+    error?: unknown;
+    setMetadata(extra: Record<string, unknown>): void;
+    disableCapture(field: 'input' | 'output' | 'toolInputs' | 'toolOutputs' | 'reasoning'): void;
+};
+export type BlypProviderOptions = {
+    logger?: BlypLogger;
+    provider?: BlypAIProvider;
+    operation?: string;
+    metadata?: Record<string, unknown>;
+    capture?: BlypCaptureOptions;
+    exclude?: BlypExcludeOptions;
+    limits?: BlypLimitOptions;
+    hooks?: {
+        onStart?: (context: BlypSDKContext) => void | Promise<void>;
+        onFinish?: (context: BlypSDKContext) => void | Promise<void>;
+        onError?: (context: BlypSDKContext) => void | Promise<void>;
+        onEvent?: (event: BlypLLMEventPart, context: BlypSDKContext) => void | Promise<void>;
+    };
+};
+export type BlypSDKContext = {
+    traceId: string;
+    provider: BlypAIProvider;
+    sdk: Exclude<BlypAISDK, 'ai-sdk'>;
+    operation: string;
+    method: string;
+    logger: BlypLogger;
+    metadata: Record<string, unknown>;
+    request: unknown;
+    response?: unknown;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+        reasoningTokens?: number;
+        cachedInputTokens?: number;
+    };
+    finishReason?: string;
+    input?: unknown;
+    output?: unknown;
+    toolCalls?: AIToolCallRecord[];
+    startedAt: string;
+    firstChunkAt?: string;
+    endedAt?: string;
+    error?: unknown;
+    setMetadata(extra: Record<string, unknown>): void;
+    disableCapture(field: 'input' | 'output' | 'toolInputs' | 'toolOutputs' | 'reasoning' | 'rawProviderPayload'): void;
+};
+export type BlypLLMTrace = {
+    provider: BlypAIProvider;
+    sdk: Exclude<BlypAISDK, 'ai-sdk'>;
+    model: string;
+    operation: string;
+    method: string;
+    streamed: boolean;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+        reasoningTokens?: number;
+        cachedInputTokens?: number;
+    };
+    finishReason?: string;
+    tools?: Array<{
+        id?: string;
+        name: string;
+        input?: unknown;
+        output?: unknown;
+        providerFormat?: unknown;
+        status: 'started' | 'completed' | 'failed';
+    }>;
+    input?: unknown;
+    output?: unknown;
+    timing: {
+        startedAt: string;
+        firstChunkAt?: string;
+        endedAt: string;
+        durationMs: number;
+        msToFirstChunk?: number;
+    };
+    metadata?: Record<string, unknown>;
+    rawProviderPayload?: unknown;
+};
+export type BlypLLMEventPart = BlypTraceEvent;
+export type BlypModelOptions = BlypProviderOptions;
+export type BlypResolvedModelOptions = {
+    logger?: BlypLogger;
+    provider?: BlypAIProvider;
+    operation?: string;
+    metadata: Record<string, unknown>;
+    capture: Required<BlypCaptureOptions>;
+    exclude: Required<BlypExcludeOptions>;
+    limits: Required<BlypLimitOptions>;
+    hooks: NonNullable<BlypModelOptions['hooks']>;
+};
+export type BlypLanguageModel = LanguageModelV3;
+export type BlypLanguageModelMiddleware = LanguageModelMiddleware;