@struct-ai/sdk 0.1.2 → 0.2.1

package/README.md

@@ -60,7 +60,7 @@ await struct.agent({ name: "checkout" }, async () => {
 | `@langchain/core` `BaseChatModel` | `.invoke`, `.stream` | `chat {model}` | Skipped when a provider-direct instrumentor is active (e.g. ChatAnthropic + Anthropic patch → single span) |
 | `@langchain/core` `StructuredTool` | `.invoke` | `execute_tool {name}` | Extracts `tool_call_id` from LangChain ToolCall input or pending queue |
 | `@langchain/core` `BaseRetriever` | `.invoke` | `retrieval {name}` | |
-| `@langchain/langgraph` `Pregel` | `.invoke`, `.stream` | `invoke_agent {name}` | Covers `createReactAgent`, custom graphs. `thread_id` → `gen_ai.conversation.id` |
+| `@langchain/langgraph` `Pregel` | `.invoke`, `.stream` | `invoke_agent {name}` | Covers `createReactAgent` and custom graphs. Reads conversation id from any of: `configurable.thread_id` (LangGraph canonical), or `metadata.{thread_id, session_id, conversation_id}` (LangSmith conventions). For multi-turn HTTP-style threading, wrap your entry point in [`struct.agent({ sessionId: convId }, ...)`](#recommended-pattern-wrap-langchain-entry-points-in-structagent) — the struct-native replacement for LangSmith's `tracing_context(parent=run_tree)`. |
 
 ## Framework integration
 
@@ -97,6 +97,39 @@ import { createReactAgent } from "@langchain/langgraph/prebuilt";
 // BaseRetriever.invoke gets retrieval spans.
 ```
 
+##### Recommended pattern: wrap LangChain entry points in `struct.agent`
+
+For multi-turn HTTP-style usage (every request continues the same
+conversation), wrap your request handler in
+`struct.agent({ sessionId: conversationId }, async () => { ... })`.
+This is the struct-native replacement for `with ls.tracing_context(parent=run_tree):`
+and gives you two things you can't get from `configurable.thread_id` alone:
+
+1. **Threading without per-call config plumbing.** Every nested
+   LangChain call inherits the conversation id via the SDK's ambient
+   AsyncLocalStorage — you don't have to ensure each `compiledGraph.invoke`
+   gets `thread_id` on its config.
+2. **One trace per request.** `struct.agent` creates a parent OTel span
+   so all the LangChain work for the request nests under one trace
+   (clean tree, "Subagents" / "Spawned by" UI links work). Without it,
+   each `.invoke()` becomes its own root trace, and the UI's session
+   list shows a non-deterministic agent name (`omni_agent`,
+   `LangGraph`, the first sub-agent it sees…).
+
+Migrating from LangSmith:
+
+```ts
+// Before — LangSmith convention, fragments under struct-sdk
+await ls.traceable(async () => {
+  await orchestrator.invoke(inputs, config);
+}, { parent: runTree })();
+
+// After — struct-native, threads correctly, no langsmith dep
+await struct.agent({ sessionId: conversationId }, async () => {
+  await orchestrator.invoke(inputs, config);
+});
+```
+
 ### LLM SDKs used directly — manual agent + tool scopes required
 
 When you call an LLM SDK directly (no agent framework wrapping it), only
@@ -201,8 +234,18 @@ await struct.agent(
 );
 ```
 
-Nested agents set `struct.agent.parent_session_id` on the inner span, linking
-subagents back to the parent.
+Sub-agents (e.g. a `createReactAgent` graph invoked from inside another
+agent's tool body) record their parent via the
+`struct.agent.parent_session_id` attribute on the inner `invoke_agent`
+span. This powers the UI's "Spawned by" backlink, which works for any
+nested invocation.
+
+The parent's "Subagents" forward list — the inverse direction — requires
+that the nested invoke inherits the parent's trace via LangChain's
+callback chain. This works automatically when the outer tool is built
+with the `tool()` factory from `@langchain/core/tools`; it does **not**
+work with `new DynamicTool({...})`, which skips the callback wrap. See
+the troubleshooting section below for the workaround.
 
 ## Semantic conventions
 

package/dist/commonjs/core.js

@@ -302,7 +302,14 @@ class StructSDK {
             // gen_ai.conversation.id is the spec-blessed name for
             // session/thread id.
             startedSpan.setAttribute(semconv_js_1.GEN_AI.CONVERSATION_ID, sessionId);
-            if (parentSessionId && parentSessionId !== sessionId) {
+            // Always set parent_session_id when there's a parent agent — even
+            // when the value matches sessionId (which happens when a nested
+            // ``struct.agent()`` inherits ambient session). The attribute is
+            // structural ("this agent has a parent agent"), not a uniqueness
+            // marker. The UI uses it to render an inline subagent expansion
+            // under the triggering call (vs the drill-in flow used when
+            // sessionIds differ).
+            if (parentSessionId) {
                 startedSpan.setAttribute(semconv_js_1.STRUCT.AGENT_PARENT_SESSION_ID, parentSessionId);
             }
             if (options.metadata) {

package/dist/commonjs/integrations/langchain-callback.js

@@ -164,7 +164,16 @@ class StructCallbackHandler {
             // agent ancestor (NOT the immediate parent run) — a subagent spawned
             // from inside a tool has the tool as its immediate parent, but we want
             // to point at the outer agent's session.
-            if (parentAgentSessionId && parentAgentSessionId !== sessionId) {
+            //
+            // Always set when there's a parent agent — even if the value matches
+            // sessionId. When the SDK's ambient session (e.g. ``struct.agent({
+            // sessionId: convId })``) propagates through nested invoke_agent
+            // spans, parent and child share sessionId. The attribute still
+            // encodes the structural "this span has a parent agent"
+            // relationship; the UI uses it to render an inline subagent
+            // expansion under the triggering tool call (vs the "View sub-agent →"
+            // drill-in flow used when sessionIds differ).
+            if (parentAgentSessionId) {
                 startedSpan.setAttribute(semconv_js_1.STRUCT.AGENT_PARENT_SESSION_ID, parentAgentSessionId);
             }
             // User prompt propagation — set gen_ai.input.messages on the agent
@@ -461,8 +470,8 @@ class StructCallbackHandler {
             if (p?.sessionId)
                 return p.sessionId;
         }
-        const threadId = metadata?.thread_id;
-        if (typeof threadId === "string" && threadId.length > 0)
+        const threadId = metadataThreadId(metadata);
+        if (threadId)
             return threadId;
         const ambient = (0, context_js_1.getSessionId)();
         if (ambient)
@@ -498,8 +507,8 @@ class StructCallbackHandler {
      * resolved session and ignore the inherited value.
      */
     resolveAgentSessionId(metadata, parentSessionId) {
-        const threadId = metadata?.thread_id;
-        if (typeof threadId === "string" && threadId.length > 0) {
+        const threadId = metadataThreadId(metadata);
+        if (threadId) {
             if (parentSessionId && threadId === parentSessionId) {
                 // Inherited from parent — treat as unset, assign fresh.
                 return (0, node_crypto_1.randomUUID)();
@@ -545,6 +554,32 @@ const AGENT_CLASSES = new Set([
     "Pregel",
     "LangGraph",
 ]);
+/**
+ * Threading-id metadata keys, in resolution order.
+ *
+ * ``thread_id`` is LangGraph's canonical name (checkpointer key); ``session_id``
+ * and ``conversation_id`` are the LangSmith conventions documented at
+ * https://docs.langchain.com/langsmith/threads — when users tag a run with any
+ * of these, we treat it as the conversation grouping key. This makes
+ * struct-sdk drop-in compatible for users following either naming.
+ */
+const THREAD_KEYS = ["thread_id", "session_id", "conversation_id"];
+/**
+ * Pull the conversation/thread id from a LangChain ``metadata`` dict.
+ * Returns ``undefined`` if no recognised key is present as a non-empty
+ * string, so callers chain to their own fallbacks (ambient session,
+ * fresh UUID).
+ */
+function metadataThreadId(metadata) {
+    if (!metadata)
+        return undefined;
+    for (const key of THREAD_KEYS) {
+        const v = metadata[key];
+        if (typeof v === "string" && v.length > 0)
+            return v;
+    }
+    return undefined;
+}
 function isAgentChain(chain, runType, _runName) {
     if (runType === "agent")
         return true;

package/dist/esm/core.js

@@ -298,7 +298,14 @@ export class StructSDK {
             // gen_ai.conversation.id is the spec-blessed name for
             // session/thread id.
             startedSpan.setAttribute(GEN_AI.CONVERSATION_ID, sessionId);
-            if (parentSessionId && parentSessionId !== sessionId) {
+            // Always set parent_session_id when there's a parent agent — even
+            // when the value matches sessionId (which happens when a nested
+            // ``struct.agent()`` inherits ambient session). The attribute is
+            // structural ("this agent has a parent agent"), not a uniqueness
+            // marker. The UI uses it to render an inline subagent expansion
+            // under the triggering call (vs the drill-in flow used when
+            // sessionIds differ).
+            if (parentSessionId) {
                 startedSpan.setAttribute(STRUCT.AGENT_PARENT_SESSION_ID, parentSessionId);
             }
             if (options.metadata) {

package/dist/esm/integrations/langchain-callback.js

@@ -161,7 +161,16 @@ export class StructCallbackHandler {
             // agent ancestor (NOT the immediate parent run) — a subagent spawned
             // from inside a tool has the tool as its immediate parent, but we want
             // to point at the outer agent's session.
-            if (parentAgentSessionId && parentAgentSessionId !== sessionId) {
+            //
+            // Always set when there's a parent agent — even if the value matches
+            // sessionId. When the SDK's ambient session (e.g. ``struct.agent({
+            // sessionId: convId })``) propagates through nested invoke_agent
+            // spans, parent and child share sessionId. The attribute still
+            // encodes the structural "this span has a parent agent"
+            // relationship; the UI uses it to render an inline subagent
+            // expansion under the triggering tool call (vs the "View sub-agent →"
+            // drill-in flow used when sessionIds differ).
+            if (parentAgentSessionId) {
                 startedSpan.setAttribute(STRUCT.AGENT_PARENT_SESSION_ID, parentAgentSessionId);
             }
             // User prompt propagation — set gen_ai.input.messages on the agent
@@ -458,8 +467,8 @@ export class StructCallbackHandler {
             if (p?.sessionId)
                 return p.sessionId;
         }
-        const threadId = metadata?.thread_id;
-        if (typeof threadId === "string" && threadId.length > 0)
+        const threadId = metadataThreadId(metadata);
+        if (threadId)
             return threadId;
         const ambient = getSessionId();
         if (ambient)
@@ -495,8 +504,8 @@ export class StructCallbackHandler {
      * resolved session and ignore the inherited value.
      */
     resolveAgentSessionId(metadata, parentSessionId) {
-        const threadId = metadata?.thread_id;
-        if (typeof threadId === "string" && threadId.length > 0) {
+        const threadId = metadataThreadId(metadata);
+        if (threadId) {
             if (parentSessionId && threadId === parentSessionId) {
                 // Inherited from parent — treat as unset, assign fresh.
                 return randomUUID();
@@ -541,6 +550,32 @@ const AGENT_CLASSES = new Set([
     "Pregel",
     "LangGraph",
 ]);
+/**
+ * Threading-id metadata keys, in resolution order.
+ *
+ * ``thread_id`` is LangGraph's canonical name (checkpointer key); ``session_id``
+ * and ``conversation_id`` are the LangSmith conventions documented at
+ * https://docs.langchain.com/langsmith/threads — when users tag a run with any
+ * of these, we treat it as the conversation grouping key. This makes
+ * struct-sdk drop-in compatible for users following either naming.
+ */
+const THREAD_KEYS = ["thread_id", "session_id", "conversation_id"];
+/**
+ * Pull the conversation/thread id from a LangChain ``metadata`` dict.
+ * Returns ``undefined`` if no recognised key is present as a non-empty
+ * string, so callers chain to their own fallbacks (ambient session,
+ * fresh UUID).
+ */
+function metadataThreadId(metadata) {
+    if (!metadata)
+        return undefined;
+    for (const key of THREAD_KEYS) {
+        const v = metadata[key];
+        if (typeof v === "string" && v.length > 0)
+            return v;
+    }
+    return undefined;
+}
 function isAgentChain(chain, runType, _runName) {
     if (runType === "agent")
         return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@struct-ai/sdk",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "Struct agent observability SDK — auto-instruments AI agent frameworks with OpenTelemetry",
   "type": "module",
   "main": "./dist/commonjs/index.js",
@@ -24,6 +24,15 @@
     "README.md",
     "LICENSE"
   ],
+  "scripts": {
+    "build": "tshy",
+    "dev": "tshy --watch",
+    "clean": "rm -rf dist .tshy .tshy-build",
+    "typecheck": "tsc --noEmit",
+    "lint": "echo 'TODO: eslint not configured for @struct-ai/sdk yet — see investigation'",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
   "keywords": [
     "struct",
     "observability",
@@ -76,25 +85,19 @@
     "@langchain/anthropic": "^0.3.0",
     "@langchain/core": "^0.3.0",
     "@langchain/langgraph": "^0.2.0",
+    "@langchain/openai": "^0.5.18",
     "@types/node": "^20.0.0",
     "nock": "^13.5.0",
     "tshy": "^3.0.0",
+    "tsx": "^4.21.0",
     "typescript": "^5.5.0",
-    "vitest": "^4.0.0"
+    "vitest": "^4.0.0",
+    "zod": "^4.4.3"
   },
   "tshy": {
     "exports": {
       ".": "./src/index.ts"
     }
   },
-  "module": "./dist/esm/index.js",
-  "scripts": {
-    "build": "tshy",
-    "dev": "tshy --watch",
-    "clean": "rm -rf dist .tshy .tshy-build",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src --max-warnings 0",
-    "test": "vitest run",
-    "test:watch": "vitest"
-  }
-}
+  "module": "./dist/esm/index.js"
+}

package/dist/node_modules/@struct-ai/sdk/dist/commonjs/content-capture.d.ts

@@ -1,10 +0,0 @@
-export declare enum ContentCaptureMode {
-    None = "none",
-    EventOnly = "event_only",
-    SpanOnly = "span_only",
-    SpanAndEvent = "span_and_event"
-}
-export declare function emitEventsFor(mode: ContentCaptureMode): boolean;
-export declare function emitSpanContentFor(mode: ContentCaptureMode): boolean;
-export declare function captureContentFor(mode: ContentCaptureMode): boolean;
-//# sourceMappingURL=content-capture.d.ts.map

package/dist/node_modules/@struct-ai/sdk/dist/commonjs/context.d.ts

@@ -1,30 +0,0 @@
-import type { Span } from "@opentelemetry/api";
-export interface StructContext {
-    sessionId?: string;
-    conversationId?: string;
-    agentSpan?: Span;
-    pendingToolCalls?: Record<string, string[]>;
-}
-export declare function getStore(): StructContext | undefined;
-export declare function getSessionId(): string | undefined;
-export declare function getConversationId(): string | undefined;
-export declare function getAgentSpan(): Span | undefined;
-export declare function getPendingToolCalls(): Record<string, string[]> | undefined;
-export declare function runWithContext<T>(patch: Partial<StructContext>, fn: () => T): T;
-export declare function ensurePendingToolCallsSlot(): Record<string, string[]>;
-/**
- * Pop the first pending tool_use id matching `name`, or undefined.
- * FIFO semantics match Python struct-sdk-python.
- */
-export declare function popPendingToolCallId(name: string): string | undefined;
-/**
- * Push (name, id) pairs into the active pending-tool-calls slot.
- * Initializes a transient dict if no active agent scope.
- */
-export declare function pushPendingToolCalls(pairs: readonly [string, string][]): void;
-/** Snapshot the store for wrapping async iterators. */
-export declare function snapshotStore(): StructContext | undefined;
-export declare function runWithStore<T>(store: StructContext | undefined, fn: () => T): T;
-/** Test-only: run `fn` inside a completely fresh context (no parent store). */
-export declare function runInFreshContext<T>(fn: () => T): T;
-//# sourceMappingURL=context.d.ts.map

package/dist/node_modules/@struct-ai/sdk/dist/commonjs/core.d.ts

@@ -1,120 +0,0 @@
-import { type Tracer } from "@opentelemetry/api";
-import { type Logger } from "@opentelemetry/api-logs";
-import { type LogRecordProcessor } from "@opentelemetry/sdk-logs";
-import type { SpanProcessor } from "@opentelemetry/sdk-trace-base";
-import { ContentCaptureMode } from "./content-capture.js";
-export declare const DEFAULT_ENDPOINT = "https://ingest.struct.ai";
-export interface InitOptions {
-    ingestKey: string;
-    serviceName?: string;
-    serviceVersion?: string;
-    environment?: string;
-    endpoint?: string;
-    captureContent?: boolean;
-    contentCapture?: ContentCaptureMode;
-    /**
-     * Maximum time `shutdown()` is allowed to spend flushing telemetry providers
-     * before returning. If the ingest endpoint is dead or slow, shutdown returns
-     * within this budget rather than hanging the host process exit. Defaults to
-     * 5000ms. Can be overridden per call via `shutdown(timeoutMs)`.
-     */
-    shutdownTimeoutMs?: number;
-}
-export interface AgentScopeOptions {
-    name: string;
-    sessionId?: string;
-    /**
-     * Stable identifier for the agent DEFINITION — `gen_ai.agent.id` per the OTel
-     * GenAI spec. Not the same as sessionId (which identifies a single
-     * invocation / conversation). Omit if you don't have a stable ID.
-     */
-    agentId?: string;
-    version?: string;
-    metadata?: Record<string, string>;
-}
-export interface ToolScopeOptions {
-    name: string;
-    toolCallId?: string;
-}
-export interface InternalLogger {
-    info(msg: string, ...args: unknown[]): void;
-    warn(msg: string, ...args: unknown[]): void;
-    debug(msg: string, ...args: unknown[]): void;
-}
-/**
- * Sites that have already logged a first-failure WARN; subsequent failures at
- * the same site log at DEBUG. Mirrors `_first_failure_logged` in the Python
- * SDK.
- *
- * Exported for tests that need to clear the set between runs so log-level
- * assertions are deterministic. Internal — not re-exported from `index.ts`,
- * so consumers cannot reach it via the package's public API surface.
- */
-export declare const firstFailureLogged: Set<string>;
-/**
- * Run `fn`; swallow any exception. The first failure per `site` logs at WARN
- * (with the error attached); subsequent failures at the same site log at
- * DEBUG. The caller's logger is passed explicitly so this helper stays a free
- * module-level function — usable from instrumentation modules that don't
- * carry an SDK reference of their own.
- *
- * Mirrors `_safe(fn, *, site)` in the Python SDK.
- */
-export declare function safe(fn: () => void, site: string, logger: InternalLogger): void;
-export declare class StructSDK {
-    private _initialized;
-    private _tracerProvider;
-    private _loggerProvider;
-    private _ingestKey;
-    private _endpoint;
-    private _contentCapture;
-    private _shutdownHook;
-    private _shutdownTimeoutMs;
-    private _internalLogger;
-    private _readyPromise;
-    /** Resolves once auto-instrumentation has attempted to patch every detected library. */
-    get ready(): Promise<void>;
-    get initialized(): boolean;
-    get endpoint(): string;
-    get ingestKey(): string;
-    get contentCapture(): ContentCaptureMode;
-    get captureContent(): boolean;
-    get emitEvents(): boolean;
-    get emitSpanContent(): boolean;
-    init(options: InitOptions): void;
-    getTracer(name?: string): Tracer;
-    getLogger(name?: string): Logger;
-    getInternalLogger(): InternalLogger;
-    /** Test-only: attach a custom span processor to the internal provider. */
-    addSpanProcessor(processor: SpanProcessor): void;
-    /** Test-only: attach a custom log record processor. */
-    addLogRecordProcessor(processor: LogRecordProcessor): void;
-    /**
-     * Shut down the SDK and flush pending telemetry.
-     *
-     * Returns within `timeoutMs` (default: SDK init's `shutdownTimeoutMs`,
-     * fallback 5000ms). If the ingest endpoint is unreachable, in-flight
-     * telemetry may be dropped — the trade-off vs. blocking process exit.
-     *
-     * In serverless / edge runtimes (Lambda, Vercel, etc.), the runtime does
-     * NOT await our `beforeExit` hook. Call `await struct.shutdown()`
-     * explicitly before your function returns or before container freeze.
-     *
-     * Safe to call multiple times. Safe to call on an SDK that failed to init
-     * or was never initialized.
-     *
-     * @param timeoutMs - Override the configured shutdown timeout for this call.
-     */
-    shutdown(timeoutMs?: number): Promise<void>;
-    /**
-     * Run `fn` inside an `invoke_agent` span scope.
-     * Matches Python's _AgentContext behavior.
-     */
-    agent<T>(options: AgentScopeOptions, fn: () => Promise<T> | T): Promise<T>;
-    /**
-     * Run `fn` inside an `execute_tool` span scope.
-     * Matches Python's _ToolContext behavior.
-     */
-    tool<T>(options: ToolScopeOptions, fn: () => Promise<T> | T): Promise<T>;
-}
-//# sourceMappingURL=core.d.ts.map

package/dist/node_modules/@struct-ai/sdk/dist/commonjs/events.d.ts

@@ -1,12 +0,0 @@
-import { type Logger } from "@opentelemetry/api-logs";
-/**
- * Emit per-message log events for an Anthropic messages.create() call.
- * Port of _emit_message_events from anthropic.py.
- */
-export declare function emitAnthropicMessageEvents(logger: Logger, messages: unknown, system: unknown): void;
-/**
- * Emit a gen_ai.choice LogRecord for an Anthropic response.
- * Port of _emit_choice_event from anthropic.py.
- */
-export declare function emitAnthropicChoiceEvent(logger: Logger, contentBlocks: unknown, stopReason: string | null | undefined): void;
-//# sourceMappingURL=events.d.ts.map

package/dist/node_modules/@struct-ai/sdk/dist/commonjs/index.d.ts

@@ -1,6 +0,0 @@
-import { StructSDK } from "./core.js";
-export { ContentCaptureMode } from "./content-capture.js";
-export type { AgentScopeOptions, InitOptions, InternalLogger, ToolScopeOptions, } from "./core.js";
-export { StructSDK } from "./core.js";
-export declare const struct: StructSDK;
-//# sourceMappingURL=index.d.ts.map

package/dist/node_modules/@struct-ai/sdk/dist/commonjs/integrations/anthropic-content.d.ts

@@ -1,24 +0,0 @@
-import { truncateField } from "../truncation.js";
-/** Part in the GenAI spec format. */
-export type Part = Record<string, unknown>;
-/**
- * Walk Anthropic response content blocks, return (name, id) pairs for tool_use blocks.
- * Port of _iter_tool_uses from anthropic.py.
- */
-export declare function iterToolUses(blocks: unknown): Array<[string, string]>;
-/**
- * Convert arbitrary content (string | block[] | unknown) → GenAI parts.
- * Port of _content_to_parts from anthropic.py.
- */
-export declare function contentToParts(content: unknown): Part[];
-/** Convert Anthropic message list → GenAI input-messages JSON string. */
-export declare function toInputMessages(messages: unknown): string;
-/** Convert response content blocks → GenAI output-messages JSON string. */
-export declare function toOutputMessages(contentBlocks: unknown, stopReason: string | null | undefined): string;
-/** Convert system prompt (string | block[]) → GenAI system_instructions JSON string. */
-export declare function toSystemInstructions(system: unknown): string;
-export declare function safeJsonForTool(obj: unknown): string;
-/** Extract the last user message's parts for parent-span propagation. */
-export declare function lastUserMessageParts(messages: unknown): Part[] | undefined;
-export { truncateField };
-//# sourceMappingURL=anthropic-content.d.ts.map

package/dist/node_modules/@struct-ai/sdk/dist/commonjs/integrations/anthropic.d.ts

@@ -1,34 +0,0 @@
-import { type Tracer } from "@opentelemetry/api";
-import type { Logger } from "@opentelemetry/api-logs";
-import { type StructSDK } from "../core.js";
-interface PatchContext {
-    tracer: Tracer;
-    sdk: StructSDK;
-    logger: Logger | undefined;
-}
-interface CreateParams {
-    model?: string;
-    max_tokens?: number;
-    temperature?: number;
-    top_p?: number;
-    top_k?: number;
-    stop_sequences?: string[];
-    messages?: unknown[];
-    system?: unknown;
-    tools?: unknown[];
-    stream?: boolean;
-}
-export declare function patch(sdk: StructSDK): Promise<void>;
-export declare function unpatch(): Promise<void>;
-type CreateMethod = (this: unknown, params: CreateParams, opts?: unknown) => unknown;
-type StreamMethod = (this: unknown, params: CreateParams, opts?: unknown) => unknown;
-/** @internal */
-export type _PatchContextForTest = PatchContext;
-/** @internal */
-export declare function _wrapCreateForTest(original: CreateMethod): CreateMethod;
-/** @internal */
-export declare function _wrapStreamForTest(original: StreamMethod): StreamMethod;
-/** @internal */
-export declare function _setActivePatchCtxForTest(ctx: PatchContext | undefined): void;
-export {};
-//# sourceMappingURL=anthropic.d.ts.map

package/dist/node_modules/@struct-ai/sdk/dist/commonjs/integrations/index.d.ts

@@ -1,5 +0,0 @@
-import type { StructSDK } from "../core.js";
-export declare const patchedIntegrations: Set<string>;
-export declare function resetPatchedIntegrations(): void;
-export declare function autoInstrument(sdk: StructSDK): Promise<void>;
-//# sourceMappingURL=index.d.ts.map