@morsehq-dev/sdk 0.4.0-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Morse
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,294 @@
+# Morse TypeScript SDK
+
+Unified observability for AI agents and infrastructure — Node backend, one SDK.
+
+> **Built for Node; safe to bundle for the browser.** The full feature set
+> targets Node.js backends (Node 18.19+ or 20.6+). Bundlers that build for
+> the browser automatically resolve the `"browser"` export condition to a
+> browser-safe build — no aliasing, no `resolve.fallback`, no config of any
+> kind on your side. This matters in practice for full-stack frameworks
+> (Next.js, Remix, SvelteKit) where the same import is compiled for both
+> the server and the client.
+>
+> In that browser build, `run()` / `span()` / `track()` / `record()` and W3C
+> `traceparent` propagation behave exactly as documented, with traces sent
+> over Morse's JSON transport. Three things are Node-only and quietly
+> inactive in a browser, because they have no browser equivalent:
+> OpenTelemetry OTLP span export, database capture (pg / mysql2
+> instrumentation), and zero-config adapter auto-detect — which hooks
+> `require()`, and a browser has none. The SDK says so once on `init()`
+> rather than leaving you to wonder.
+>
+> This is bundle compatibility for full-stack apps, not a client-side
+> analytics product: there is no session replay, no RUM, and no
+> browser-specific instrumentation.
+
+## Install
+
+```bash
+npm install @morsehq-dev/sdk
+```
+
+Adapters are peer dependencies — install only the SDKs you actually
+use (`@anthropic-ai/sdk`, `@anthropic-ai/claude-agent-sdk`,
+`@openai/agents`, `@langchain/core`, `@langchain/langgraph`, `ai`).
+Nothing else is pulled in for adapters you don't use.
+
+## Quick Start
+
+```ts
+import * as morse from "@morsehq-dev/sdk";
+
+morse.init({ apiKey: process.env.MORSE_API_KEY });
+
+morse.record({
+  agent: "lead-qualifier",
+  success: true,
+  outcome: "qualified",
+  cost: 0.043,
+});
+```
+
+Or trace a multi-step run:
+
+```ts
+await morse.run({ agentName: "lead-qualifier" }, async (handle) => {
+  await morse.spanAsync({ name: "fetch-lead", type: "tool" }, async () => {
+    /* ... */
+  });
+  handle.setOutcome(true, "qualified");
+});
+```
+
+`record()`/`run()`/`span()` all send real OpenTelemetry spans over OTLP
+by default — see [Transport](#transport) below.
+
+## Zero-config instrumentation
+
+Once `morse.init()` runs (or `MORSE_API_KEY` is set in the environment),
+the SDK scans for already-loaded — and lazily requires — supported
+libraries and wraps them automatically. Today that covers
+`@anthropic-ai/sdk` and the Vercel AI SDK (`ai`); every call already
+loaded or `require()`d after init gets traced with no further code
+changes. Opt out with `MORSE_DISABLE_AUTO_DETECT=1`.
+
+The other adapters below (`anthropic-agent-sdk`, `openai-agents`,
+`langgraph`, `langchain`) don't have a zero-config path yet — call
+their wrap function explicitly, once, at startup. The SDK logs a
+one-time hint naming the exact call when it detects one of these
+installed without being wrapped.
+
+## Adapters
+
+Each adapter is a separate subpath export so you only pull in what you
+use.
+
+### `@morsehq-dev/sdk/anthropic` — Anthropic Messages API
+
+```ts
+import Anthropic from "@anthropic-ai/sdk";
+import { wrapAnthropic } from "@morsehq-dev/sdk/anthropic";
+
+const client = wrapAnthropic(new Anthropic());
+// every messages.create call now emits an `llm` span automatically
+```
+
+Auto-installed by zero-config detection too — `wrapAnthropic()` is a
+no-op on a client if a global auto-detect install is already active
+(no double-recording). Pass `{ summarize: true }` to also emit a
+sibling `memory` span per call.
+
+### `@morsehq-dev/sdk/anthropic-agent-sdk` — Claude Agent SDK
+
+Wraps `ClaudeSDKClient` from `@anthropic-ai/claude-agent-sdk`. Emits an
+outer **agent** span, per-call **llm** spans (with `context_segments`),
+**tool** spans, **subagent.spawn** spans for Task-tool fan-out, and
+**hook** spans for `pre_tool` / `post_tool` / `on_error` hooks.
+
+```ts
+import { ClaudeSDKClient } from "@anthropic-ai/claude-agent-sdk";
+import { wrapClaudeAgentSDKWithFullInstrumentation } from "@morsehq-dev/sdk/anthropic-agent-sdk";
+
+const raw = new ClaudeSDKClient({
+  /* ... */
+});
+const { client, dispose } = wrapClaudeAgentSDKWithFullInstrumentation(raw);
+
+for await (const event of client.query("research the 2026 RLHF landscape")) {
+  // your code unchanged — spans flow to Morse as a side-effect
+}
+dispose();
+```
+
+### `@morsehq-dev/sdk/openai-agents` — OpenAI Agents SDK
+
+Wraps `Runner` from `@openai/agents`. Emits an outer **agent** span,
+**llm** + **tool** spans, **subagent.spawn**-shaped spans for
+`handoff` events, and **guardrail** spans with pass/fail status.
+
+```ts
+import { Runner, Agent } from "@openai/agents";
+import { wrapRunnerWithFullInstrumentation } from "@morsehq-dev/sdk/openai-agents";
+
+const raw = new Runner();
+const { runner, dispose } = wrapRunnerWithFullInstrumentation(raw);
+const agent = new Agent({ name: "triage", model: "gpt-4o" /* ... */ });
+await runner.run(agent, userInput);
+dispose();
+```
+
+### `@morsehq-dev/sdk/langgraph` — LangGraph JS
+
+`MorseCallbackHandler`, a `BaseCallbackHandler` you pass via
+`callbacks`. Emits **agent** spans per chain (nested chains nest
+properly), **llm** + **tool** spans, and aggregates streaming tokens
+onto the parent llm span rather than emitting per-token spans.
+
+```ts
+import { MorseCallbackHandler } from "@morsehq-dev/sdk/langgraph";
+
+const handler = new MorseCallbackHandler();
+const result = await graph.invoke(input, { callbacks: [handler] });
+```
+
+### `@morsehq-dev/sdk/langchain` — plain LangChain (chains, LLMs, tools, retrievers)
+
+`MorseCallbackHandler` for `@langchain/core` outside a LangGraph graph
+— a structural sibling of the `langgraph` adapter, not a subclass.
+Doesn't auto-create a trace when none is active; wrap the invocation in
+`morse.run()`/`runAsync()`.
+
+```ts
+import { MorseCallbackHandler } from "@morsehq-dev/sdk/langchain";
+import { runAsync } from "@morsehq-dev/sdk";
+
+const handler = new MorseCallbackHandler({ agentName: "my-agent" });
+await runAsync({ agentName: "my-agent" }, async () => {
+  await chain.invoke(input, { callbacks: [handler] });
+});
+```
+
+### `@morsehq-dev/sdk/vercel-ai` — Vercel AI SDK
+
+One `agent` span per top-level `streamText` / `generateText` /
+`generateObject` invocation. **Not** zero-config auto-detected — `ai`'s
+named exports are non-configurable getters on its module namespace (it
+ships pure ESM), so there is nothing a monkey-patch can reassign, unlike
+`@anthropic-ai/sdk`'s `Messages.prototype.create`. Resolve traced
+replacement functions once and call those instead of `ai`'s own:
+
+```ts
+import { createTracedVercelAI } from "@morsehq-dev/sdk/vercel-ai";
+
+const { streamText, generateText, generateObject } = await createTracedVercelAI();
+// use streamText(...) / generateText(...) / generateObject(...) exactly
+// like ai's own — same call signature, same return shape.
+```
+
+### `@morsehq-dev/sdk/integrations/pino` — pino log forwarding
+
+Ship pino log lines to Morse, auto-correlated with the active trace.
+
+```ts
+import pino from "pino";
+import { morsePinoDestination } from "@morsehq-dev/sdk/integrations/pino";
+
+const logger = pino(
+  { level: "info" },
+  pino.multistream([{ stream: process.stdout }, { stream: morsePinoDestination() }]),
+);
+```
+
+### Shared metadata schema
+
+The agent-SDK adapters (`anthropic-agent-sdk`, `openai-agents`,
+`langgraph`, `langchain`) tag every span with
+`metadata.adapter ∈ {"anthropic-agent-sdk", "openai-agents", "langgraph-js", "langchain-js"}`.
+Span types use the same vocabulary regardless of source adapter —
+dashboards never branch on adapter origin. `subagent.spawn` and `hook`
+are modeled as `type=agent` + `metadata.spawn_kind="subagent"` and
+`type=tool` + `metadata.tool_kind="hook"` respectively until the
+backend `SpanType` enum gains native variants.
+
+## Cost
+
+`cost_usd` is computed automatically from the model + token counts on
+every `llm` span the adapters above emit, using a bundled pricing
+table — no separate call needed, and an explicit value the adapter
+already knows (e.g. from a provider response) always wins over the
+computed one. `record()` doesn't auto-compute — pass `cost` yourself
+if you have it.
+
+## Infra auto-capture (opt-in)
+
+Zero-config `db` spans for Postgres (`pg`), MySQL (`mysql2`), and
+SQLite (`better-sqlite3`) — correlated with the active `morse.span()`/
+`morse.run()` via real OpenTelemetry context propagation. Off by
+default; enable with `MORSE_CAPTURE_DB=1` (or `MORSE_CAPTURE_INFRA=1`).
+No code changes needed beyond the env var — the SDK registers the
+matching community OTel instrumentation package for whichever driver
+is actually installed.
+
+## Transport
+
+`run()`/`span()`/`record()` emit real `@opentelemetry/sdk-trace-node`
+spans over OTLP (protobuf+gzip) — the same transport architecture as
+the Python SDK. `MORSE_LEGACY_TRANSPORT=1` reverts to a plain
+JSON-over-fetch batcher as an escape hatch during a migration window;
+you shouldn't need it. `track()`/`batchTrack()` are a lower-level,
+non-trace-shaped escape hatch of their own — prefer `record()`.
+
+## PII Redaction
+
+Client-side redaction, **default-on**. Sensitive strings (API keys,
+JWTs, credit-card numbers, SSNs, emails, phone numbers) are rewritten
+to `[REDACTED:<kind>]` markers inside your process before any data
+leaves for the Morse ingest endpoint. The same pattern catalogue ships
+in the Python SDK and the server-side ingest layer.
+
+```ts
+import { init } from "@morsehq-dev/sdk";
+
+init({
+  apiKey: process.env.MORSE_API_KEY,
+  redaction: {
+    enabled: true, // default
+    disabledPatterns: ["email"], // turn off email-only
+    extraPatterns: ["INTERNAL-[\\w-]+"],
+  },
+});
+```
+
+- **Mandatory patterns cannot be disabled at the SDK.** Trying to
+  disable `api_key_prefixed`, `jwt`, `credit_card`, or `ssn_us` makes
+  `init()` throw at construction time.
+- **Invalid extra regexes throw at `init()`.** Each entry must compile
+  via `new RegExp(...)`; the array must be ≤ 10 entries, each pattern
+  ≤ 256 characters.
+- **Disabling redaction at the SDK does NOT bypass the server.** The
+  ingest layer always re-runs the mandatory pattern set before writing
+  anything to durable storage.
+
+| Key                | Match                                                                        | Replacement              |
+| ------------------ | ---------------------------------------------------------------------------- | ------------------------ |
+| `api_key_prefixed` | `sk-…`, `sk_(live\|test)_…`, `mhq_…`, `ghp_…`, `xox[bopsa]-…`, `AKIA…`, etc. | `[REDACTED:api_key]`     |
+| `jwt`              | `eyJ…<dot>eyJ…<dot>…` (≥16 chars per segment)                                | `[REDACTED:jwt]`         |
+| `credit_card`      | 13–19 digit groups passing Luhn                                              | `[REDACTED:credit_card]` |
+| `email`            | RFC-5322-ish `local@domain.tld`                                              | `[REDACTED:email]`       |
+| `phone_us`         | US phone formats                                                             | `[REDACTED:phone]`       |
+| `phone_e164`       | International E.164                                                          | `[REDACTED:phone]`       |
+| `ssn_us`           | `999-99-9999` (with standard exclusions)                                     | `[REDACTED:ssn]`         |
+| `ip_address`       | IPv4 + IPv6 — **default OFF** (often legitimate metadata)                    | `[REDACTED:ip]`          |
+
+## Docs
+
+Full reference — every adapter, all `init()` options, configuration,
+troubleshooting — lives at **[docs.morsehq.dev](https://docs.morsehq.dev)**.
+This README stays a quickstart.
+
+## Naming
+
+The npm package is `@morsehq-dev/sdk` (the npm org that exists is
+`morsehq-dev` — npm ties a package scope 1:1 to its owning org login).
+`@morsehq/sdk` is only the internal pnpm workspace identifier used
+inside this monorepo; it is never the published registry name.

package/dist/anthropic/index.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+var chunk7YCENA54_cjs = require('../chunk-7YCENA54.cjs');
+require('../chunk-7EO7MQBA.cjs');
+require('../chunk-KBWPNIH4.cjs');
+require('../chunk-FJUNILZT.cjs');
+
+
+
+Object.defineProperty(exports, "MAX_SEGMENT_CONTENT_BYTES", {
+  enumerable: true,
+  get: function () { return chunk7YCENA54_cjs.MAX_SEGMENT_CONTENT_BYTES; }
+});
+Object.defineProperty(exports, "_resetAnthropicInstallStateForTesting", {
+  enumerable: true,
+  get: function () { return chunk7YCENA54_cjs._resetAnthropicInstallStateForTesting; }
+});
+Object.defineProperty(exports, "extractAnthropicSegments", {
+  enumerable: true,
+  get: function () { return chunk7YCENA54_cjs.extractAnthropicSegments; }
+});
+Object.defineProperty(exports, "instrumentAnthropic", {
+  enumerable: true,
+  get: function () { return chunk7YCENA54_cjs.instrumentAnthropic; }
+});
+Object.defineProperty(exports, "isAnthropicWrapped", {
+  enumerable: true,
+  get: function () { return chunk7YCENA54_cjs.isAnthropicWrapped; }
+});
+Object.defineProperty(exports, "uninstallAnthropic", {
+  enumerable: true,
+  get: function () { return chunk7YCENA54_cjs.uninstallAnthropic; }
+});
+Object.defineProperty(exports, "wrapAnthropic", {
+  enumerable: true,
+  get: function () { return chunk7YCENA54_cjs.wrapAnthropic; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/anthropic/index.cjs.map

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

package/dist/anthropic/index.d.cts

@@ -0,0 +1,213 @@
+import { C as ContextSegment } from '../spans-DZtMuBvc.cjs';
+
+/**
+ * `@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 };