@morsehq-dev/sdk 0.4.0-rc.1

package/dist/anthropic/index.d.ts

@@ -0,0 +1,213 @@
+import { C as ContextSegment } from '../spans-DZtMuBvc.js';
+
+/**
+ * `@morsehq-dev/sdk/anthropic` — Anthropic SDK instrumentation.
+ *
+ * Wraps `@anthropic-ai/sdk` `client.messages.create` so every Claude call
+ * emits an `llm` span carrying pre-segmented `context_segments`. The
+ * server-side classifier then skips its own messages-array partitioning
+ * and persists the SDK-supplied segments verbatim.
+ *
+ * Two entry points:
+ *
+ *   - `wrapAnthropic(client)` — returns a Proxy-like wrapper that
+ *     intercepts `messages.create`. Always succeeds. The customer keeps
+ *     using the wrapper as if it were the real client.
+ *
+ *   - `instrumentAnthropic(client?)` — top-level helper. If a client is
+ *     passed, returns the wrapped form. If no client is passed AND the
+ *     `@anthropic-ai/sdk` package can be loaded, attempts to patch
+ *     `Messages.prototype.create` so every fresh `new Anthropic()` is
+ *     instrumented automatically. The prototype path is best-effort —
+ *     it is documented as fragile across Anthropic SDK versions, and
+ *     `wrapAnthropic` is the recommended public entry.
+ *
+ * Idempotent. `uninstallAnthropic()` restores the prototype and clears
+ * the install sentinel.
+ *
+ * Wrapped under `absorbErrors*` so a tracing failure can never break the
+ * customer's Anthropic call — at worst, calls go untraced.
+ *
+ * Mirrors `apps/sdk/typescript/src/vercel-ai/index.ts` in shape and
+ * `openspec/changes/.../specs/observability/spec.md` (CTX-08) in
+ * segmentation contract.
+ */
+
+/**
+ * Subset of `@anthropic-ai/sdk`'s `MessageCreateParams` we read from. We
+ * deliberately decline to import the real types so the SDK works even when
+ * `@anthropic-ai/sdk` isn't installed (it's an optional peer dep).
+ */
+interface AnthropicMessageCreateParams {
+    model: string;
+    max_tokens?: number;
+    system?: string | AnthropicTextBlockParam[];
+    messages: AnthropicMessageParam[];
+    tools?: AnthropicToolParam[];
+    tool_choice?: unknown;
+    [key: string]: unknown;
+}
+interface AnthropicTextBlockParam {
+    type: "text";
+    text: string;
+    cache_control?: {
+        type: "ephemeral";
+    } | null;
+}
+interface AnthropicToolUseBlockParam {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: unknown;
+}
+interface AnthropicToolResultBlockParam {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string | Array<{
+        type: string;
+        text?: string;
+        [k: string]: unknown;
+    }>;
+    is_error?: boolean;
+}
+type AnthropicContentBlockParam = AnthropicTextBlockParam | AnthropicToolUseBlockParam | AnthropicToolResultBlockParam | {
+    type: string;
+    [k: string]: unknown;
+};
+interface AnthropicMessageParam {
+    role: "user" | "assistant" | string;
+    content: string | AnthropicContentBlockParam[];
+}
+interface AnthropicToolParam {
+    name: string;
+    description?: string;
+    input_schema?: unknown;
+    [key: string]: unknown;
+}
+interface AnthropicUsage {
+    input_tokens?: number;
+    output_tokens?: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+    [key: string]: unknown;
+}
+interface AnthropicMessageResponse {
+    id?: string;
+    model?: string;
+    usage?: AnthropicUsage;
+    content?: Array<{
+        type: string;
+        text?: string;
+        [k: string]: unknown;
+    }>;
+    [key: string]: unknown;
+}
+/**
+ * Structural shape of the Anthropic client we wrap. We only require that
+ * `client.messages.create` is a function returning a Promise.
+ */
+interface AnthropicClientLike {
+    messages: {
+        create(params: AnthropicMessageCreateParams, options?: unknown): Promise<AnthropicMessageResponse>;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+interface InstrumentAnthropicOptions {
+    /**
+     * When provided, used as the parent agent span's name. Defaults to
+     * `"anthropic.messages.create"`.
+     */
+    defaultAgentName?: string;
+    /**
+     * If a fresh Anthropic *module* import is passed (e.g.,
+     * `await import("@anthropic-ai/sdk")`), the adapter will best-effort
+     * patch `Messages.prototype.create`. Most users should prefer
+     * `wrapAnthropic(client)` instead.
+     */
+    anthropicModule?: unknown;
+    /**
+     * When `true` (MEM-11), every wrapped `messages.create` call also
+     * emits a sibling `memory`-type span with
+     * `metadata.memory_op_type="consolidate"`, `parent_span_id` linking
+     * back to the LLM span (server treats this as `producer_span_id`),
+     * `metadata.summary_token_count` from the response's output_tokens,
+     * and `metadata.summary_content_hash` (SHA-256 of the response's
+     * first text block).
+     *
+     * Use this flag when the customer is calling Claude to summarize
+     * their own conversation context (the customer-side compaction
+     * pattern). Default `false` — existing callers see zero behavior change.
+     *
+     * Opt-in only. The adapter never auto-detects summarization from
+     * system-prompt content (too many false positives).
+     */
+    summarize?: boolean;
+}
+/**
+ * Wrap an Anthropic client so every `messages.create` call records an
+ * `llm` span with `context_segments`. The wrapper preserves the rest of
+ * the client's surface (other resources, helpers, etc.) via a Proxy.
+ *
+ * Idempotent — a previously wrapped client is returned as-is.
+ */
+declare function wrapAnthropic<C extends AnthropicClientLike>(client: C, options?: InstrumentAnthropicOptions): C;
+/**
+ * Top-level installer. Two modes:
+ *
+ *   - `instrumentAnthropic(client)` — equivalent to `wrapAnthropic(client)`.
+ *   - `instrumentAnthropic({ anthropicModule: mod })` — best-effort
+ *     prototype patch. Prefer the wrap form when possible.
+ *
+ * Always returns the wrapped client, or `undefined` if patching failed.
+ * Errors are absorbed; this function never throws back at the caller.
+ */
+declare const instrumentAnthropic: <C extends AnthropicClientLike>(clientOrOptions?: InstrumentAnthropicOptions | C | undefined, maybeOptions?: InstrumentAnthropicOptions | undefined) => Promise<boolean | C | undefined>;
+/**
+ * Restore the prototype patch and clear the install sentinel.
+ *
+ * Pass the same module reference that was given to `instrumentAnthropic`
+ * (or omit and the function will try to dynamic-import it). Calling
+ * `uninstallAnthropic()` on a wrapped client (vs. a module) is a no-op —
+ * just discard the wrapped client.
+ */
+declare const uninstallAnthropic: (anthropicModule?: unknown) => void | undefined;
+/**
+ * Reset module-level install state for tests. Not part of the public API.
+ * @internal
+ */
+declare function _resetAnthropicInstallStateForTesting(): void;
+/** True when a wrapped Anthropic client is passed in. */
+declare function isAnthropicWrapped(client: unknown): boolean;
+/**
+ * Maximum bytes of `content` we ship per segment. Long blobs are truncated
+ * with `content_truncated: true`. The server further enforces its own
+ * cap; we keep the SDK floor lower to stay friendly to mobile networks.
+ */
+declare const MAX_SEGMENT_CONTENT_BYTES = 4096;
+/**
+ * Extract `ContextSegment[]` from an Anthropic `messages.create` request
+ * + response. The ordering is:
+ *
+ *   1. `tools` → one `tool_descriptions` segment, position 0.
+ *   2. `system` → `system_prompt` segment.
+ *   3. Each prior `user` / `assistant` message → `chat_history` segment.
+ *      `tool_result` blocks (always inside `user.content`) become their
+ *      own `tool_observation` segments.
+ *      `tool_use` blocks (assistant-emitted) roll into the parent
+ *      assistant `chat_history` segment as part of the JSON content.
+ *   4. The final `user` message → `current_input`.
+ *
+ * Cache state heuristic:
+ *   - `system` blocks with `cache_control.type === "ephemeral"` →
+ *     `cache_write`.
+ *   - If the response reports `cache_read_input_tokens > 0`, mark the
+ *     `system_prompt` and `tool_descriptions` segments as `cache_hit`
+ *     (overrides `cache_write` — the cache HIT is more informative
+ *     than the cache write attempt).
+ *
+ * `tokens` is intentionally left undefined — the server tokenizes.
+ */
+declare function extractAnthropicSegments(params: AnthropicMessageCreateParams, response?: AnthropicMessageResponse): ContextSegment[];
+
+export { type AnthropicClientLike, type AnthropicContentBlockParam, type AnthropicMessageCreateParams, type AnthropicMessageParam, type AnthropicMessageResponse, type AnthropicTextBlockParam, type AnthropicToolParam, type AnthropicToolResultBlockParam, type AnthropicToolUseBlockParam, type AnthropicUsage, type InstrumentAnthropicOptions, MAX_SEGMENT_CONTENT_BYTES, _resetAnthropicInstallStateForTesting, extractAnthropicSegments, instrumentAnthropic, isAnthropicWrapped, uninstallAnthropic, wrapAnthropic };

package/dist/anthropic/index.js

@@ -0,0 +1,6 @@
+export { MAX_SEGMENT_CONTENT_BYTES, _resetAnthropicInstallStateForTesting, extractAnthropicSegments, instrumentAnthropic, isAnthropicWrapped, uninstallAnthropic, wrapAnthropic } from '../chunk-CKFOGDUF.js';
+import '../chunk-RTL23YOQ.js';
+import '../chunk-XTKMUJWI.js';
+import '../chunk-TQWI4UYO.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/anthropic/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}