@tracehatch/sdk 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## 0.3.0
+
+- Use only the Tracehatch client, environment variables and request headers.
+- Remove retired class aliases and configuration fallbacks.
+- Use Tracehatch names for process state, identifier hashes, conversation
+  fingerprints, capture metadata and product-specific span attributes.
+- Keep server-only capture, ESM/CommonJS shared context and the hosted API default.

package/GUIDE.md

@@ -0,0 +1,387 @@
+# Tracehatch SDK guide
+
+Record agent runs, model calls, tool steps and sessions in Tracehatch from Node.js
+18 or newer. The package supports ESM and CommonJS and has no runtime
+dependencies.
+
+## Install and configure
+
+Install the SDK in the **server package that makes model calls**:
+
+```sh
+npm install @tracehatch/sdk@0.3.0
+# Or: pnpm add @tracehatch/sdk@0.3.0
+# Or: yarn add @tracehatch/sdk@0.3.0
+```
+
+The package is MIT licensed. Your dashboard at [tracehatch.com](https://tracehatch.com)
+also provides the same SDK as a versioned archive when you need that installation path:
+
+```sh
+npm install https://tracehatch.com/downloads/tracehatch-sdk-0.3.0.tgz
+```
+
+Create a project API key in Tracehatch. The key selects the project and environment.
+Configuration comes from the environment:
+
+| Variable              | Purpose                                                                                                                              |
+| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
+| `TRACEHATCH_API_KEY`  | Required. Without it the SDK stays disabled and sends nothing.                                                                       |
+| `TRACEHATCH_BASE_URL` | Optional. Your API origin for a self-hosted or local Tracehatch; `/api/v1` bases work too. Defaults to `https://api.tracehatch.com`. |
+| `TRACEHATCH_AGENT`    | Optional. Agent name; defaults to the nearest `package.json` name.                                                                   |
+| `TRACEHATCH_RELEASE`  | Optional. Release; defaults to `VERCEL_GIT_COMMIT_SHA`, `GITHUB_SHA` and similar, then git `HEAD`.                                   |
+
+Keep the key in the server environment and never expose it in browser code.
+
+Load the SDK before anything else so provider clients are created after it:
+
+```sh
+node --import @tracehatch/sdk/auto server.js
+```
+
+```ts
+// or, as the first line of the entry file
+import "@tracehatch/sdk/auto"
+```
+
+CommonJS: `require("@tracehatch/sdk/auto")`. Next.js: create
+`instrumentation.ts` beside `app` or `pages`, inside `src` when the application
+uses `src/app` or `src/pages`:
+
+```ts
+export async function register() {
+  if (process.env.NEXT_RUNTIME === "nodejs")
+    await import("@tracehatch/sdk/auto")
+}
+```
+
+The auto entry calls `init()` with the environment. Call `init()` yourself
+instead when you want options:
+
+```ts
+import { init } from "@tracehatch/sdk"
+
+init({
+  agent: "support-agent",
+  captureBodies: false,
+  redact: { rules: [{ name: "customer", pattern: /CUSTOMER-\d+/g }] },
+  sampling: { rate: 0.25 },
+})
+```
+
+`init` options: `apiKey`, `baseUrl`, `agent`, `release`, `captureBodies`
+(default `true`), `redact` (`false` or `{ builtIns?, rules? }`), `sampling`
+(`{ rate }`, head sampling per run), `debug`, `flushOnExit` (default `true`).
+Unknown options are rejected. `init()` replaces an earlier client and installs
+the capture hooks; `shutdown()` removes them.
+
+## Check the connection
+
+Save this as `tracehatch-check.mjs` in the consuming package, load
+`TRACEHATCH_API_KEY` (and `TRACEHATCH_BASE_URL` for a local API) into the process
+with your existing configuration, then run `node tracehatch-check.mjs`. On Node 22
+or newer `node --env-file=.env tracehatch-check.mjs` also works.
+
+```js
+import "@tracehatch/sdk/auto"
+import { trace, flushWithResult, shutdown } from "@tracehatch/sdk"
+
+try {
+  const traceId = await trace("tracehatch-setup-check", (run) => run.id)
+  const result = await flushWithResult()
+  if (result.status !== "accepted")
+    throw new Error(`Delivery was not confirmed: ${JSON.stringify(result)}`)
+  console.log({ traceId, delivery: result.status })
+} finally {
+  await shutdown()
+}
+```
+
+`accepted` requires the API's `202` receipt with a matching span count. It
+proves ingestion acceptance; the project's trace view confirms processing. A
+web page at the wrong URL, a rejected key, a timeout and disabled tracing cannot
+be mistaken for a successful check.
+
+## What is captured
+
+Capture happens at the HTTP boundary: the SDK observes the runtime's global
+`fetch`, so any client or framework that uses it is recorded without wrapping.
+The request body names the model call; the response is read from a clone while
+your code consumes the original. A capture failure never changes the response
+or the error your application receives.
+
+| Request                                                                         | Recorded as                                                          |
+| ------------------------------------------------------------------------------- | -------------------------------------------------------------------- |
+| `POST …/chat/completions`                                                       | `generation` span, `chat.completions`                                |
+| `POST …/responses`, `GET …/responses/{id}`, `POST …/responses/{id}/cancel`      | `generation` span, `responses`; polls complete a background response |
+| `POST …/embeddings`                                                             | `embedding` span                                                     |
+| `POST …/messages` on `api.anthropic.com`, or with an `anthropic-version` header | `generation` span, `messages`                                        |
+
+`gen_ai.system` is `openai` or `anthropic` on the official hosts, a known name
+for Azure OpenAI, Groq, Mistral, Together, OpenRouter, DeepSeek, xAI,
+Perplexity, Fireworks, Cerebras, Gemini's OpenAI-compatible endpoint and
+Ollama, and the hostname otherwise. Pricing follows the model name when the
+system is unknown.
+
+Recorded per call: model, request settings, reported token usage (including
+cached and cache-creation input and reasoning tokens), finish reasons, tool
+call counts, time to first token and tokens per second for streams, the HTTP
+status, provider error types (`rate_limit`, `timeout`, `auth`,
+`invalid_request`, `provider_error`, `incomplete_stream`,
+`incomplete_response`) and, with body capture on, the request, messages and
+assembled output. A provider client's retry of the same request within a minute
+of a failure is recorded as attempt 2, 3 and so on.
+
+Streams: the SDK reads its own copy while your code reads the response, so a
+stream returned out of a `trace()` callback and consumed later is still
+recorded; the run's end waits for it, bounded by two minutes, and `flush()`
+waits for such ends too. A stream your code neither reads nor cancels is
+recorded as cancelled when that bound passes. Cancelling through an `AbortSignal` records a
+cancelled span. For OpenAI chat streams `stream_options.include_usage: true` is
+added when you have not set the option, so usage is reported; an explicit
+`false` stays false.
+
+Not captured: clients constructed before the SDK loaded (they keep the original
+`fetch`), clients given their own `fetch` option, non-JSON request bodies such
+as audio uploads, and endpoints outside the table.
+
+## Runs, sessions and tools without code
+
+**Runs.** Inside an inbound HTTP request handled by `http.Server` or
+`https.Server` (Express, Fastify, NestJS, Next.js) every model call belongs to
+one run named `METHOD /path`; the run is sent only when a model call or an
+explicit span happened, ends when the response finishes, and is marked failed
+on a 5xx status. Outside a request (scripts, queues, workers) a model call
+starts a run. If the response asks for tools, the run stays open for the tool
+step and the follow-up call that carries the tool results; a response without
+tool calls, a failure, a new user message, ten idle minutes or process exit
+ends it. Explicit `trace()` runs take precedence over both.
+
+Automatic runs also populate their transcript with the current user message
+from the first provider call and the latest textual model answer. Tool
+arguments and reasoning remain on the generation span. Explicit traces keep
+application-supplied input and output. Inferred transcripts use the same
+redaction, truncation, and `captureBodies: false` policy as other bodies.
+
+**Sessions and users.** In order: the `x-tracehatch-session-id` and
+`x-tracehatch-user-id` request headers, `setSession()` / `setUser()`, the OpenAI
+Responses `conversation` id or `previous_response_id`, then a fingerprint of
+the conversation's system prompt and first user message, which every later
+turn resends. Derived session ids look like `auto-` followed by 32 hex
+characters and are identical across processes, restarts and the gateway. The
+OpenAI `user` field and Anthropic `metadata.user_id` name the end user.
+
+**Tools.** Tool calls in a response are paired with the tool results in the
+next request (chat `tool` messages, Responses `function_call_output` items,
+Anthropic `tool_result` blocks) and recorded as `tool` spans with the call id,
+name, arguments, output, error flag and the time between the two calls.
+
+When timing that same provider-requested tool with `tool()`, include
+`attributes: { "tool.call_id": call.id }` in its options. The explicit span then
+takes precedence over the inferred span, retaining its real timing and retry
+events. A matching name alone cannot identify one tool execution reliably.
+
+**Identity.** The run's `agent` is the nearest `package.json` name and the
+`release` is the deployment's commit unless `init` or the environment says
+otherwise. Automatic runs carry `metadata["tracehatch.capture"] = "auto"`.
+
+## Precision when you want it
+
+The explicit API works alongside automatic capture; model calls made inside a
+`trace()` become children of it.
+
+```ts
+import OpenAI from "openai"
+import { trace, tool, setSession, setUser, flush } from "@tracehatch/sdk"
+
+const openai = new OpenAI()
+
+await trace("answer question", async (run) => {
+  setSession("conversation-42")
+  setUser({ id: "user-7" })
+  const context = await tool("search docs", async () => "Refunds take 5 days")
+  const answer = await openai.chat.completions.create({
+    model: "YOUR_EXISTING_MODEL_ID",
+    messages: [{ role: "user", content: `Explain: ${context}` }],
+  })
+  run.addTags("support")
+  return answer
+})
+await flush()
+```
+
+Both `trace` and `span` return promises; await them even for synchronous
+callbacks. For an explicit lifetime:
+
+```ts
+import { startTrace, span, shutdown } from "@tracehatch/sdk"
+
+const run = startTrace("import documents", { tags: ["batch"] })
+try {
+  await run.run(() => span("parse", "custom", async () => "parsed"))
+  run.end({ output: { imported: 1 } })
+} catch (error) {
+  run.end({ outcome: "error", error })
+  throw error
+} finally {
+  await shutdown()
+}
+```
+
+Trace handles support `setInput`, `setOutput`, `setUser`, `setSession`,
+`addTags`, `setMetadata` and `score`. Span handles support `setOutput`,
+`setAttributes` and `addEvent(name, attributes?, level?)`. Top-level context
+helpers update the active run. Concurrent spans keep their own parents. Nested
+traces receive `metadata.parent_trace_id`. A `span()` or `tool()` recorded
+outside any run becomes a run of its own.
+
+`tool(name, fn, { retries: 2, backoffMs: 100 })` makes up to three attempts in
+one span, with an event per attempt. Retries default to zero. Only opt into
+retries when the tool operation can safely be repeated. Provider client
+retries are recorded as separate attempts of the generation.
+
+For a provider the SDK does not recognise, record the call yourself:
+
+```ts
+import { trace, span } from "@tracehatch/sdk"
+
+await trace("answer question", () =>
+  span("model call", "generation", async (step) => {
+    const result = await existingModelCall()
+    step.setAttributes({
+      "gen_ai.system": existingProviderName,
+      "gen_ai.request.model": existingModelId,
+    })
+    return result
+  })
+)
+```
+
+## Scores
+
+Record numeric or categorical scores while the run is open:
+
+```ts
+import { trace, span, score } from "@tracehatch/sdk"
+
+await trace("answer question", async (run) => {
+  await span("check answer", "custom", async (step) => {
+    score({ name: "correctness", value: "pass", spanId: step.id })
+  })
+  run.score({ name: "confidence", value: 0.95, comment: "Evidence matched" })
+})
+```
+
+`score({ name, value, comment?, spanId? })` uses the current run;
+`run.score(...)` works with a manual `startTrace` handle too. Without `spanId`,
+the score belongs to the run. Call before `run.end()` or before the trace
+callback returns. Calls outside a recording run, after end, or with invalid
+values are ignored. There are at most 100 SDK scores per run; each gets a
+stable `scr_` id so retries cannot create duplicates. Numeric values must be
+finite; categorical values must be nonempty. Names, categories and comments
+are redacted and bounded to 128, 256 and 2,048 characters respectively.
+
+Scores travel with subsequent completed spans, including the final root. Flush
+after the run ends to send its final scores. The worker keeps a span-targeted
+score pending until that span arrives and its project, environment and run
+match. Scores are private project data available in the trace scores API;
+public share links omit them.
+
+## Data and delivery
+
+Body capture defaults to on. Built-in redaction masks email addresses, phone
+numbers, valid card-shaped strings, IBANs, and common API key/secret patterns.
+Credential fields are masked too. It runs on bodies, attributes, metadata,
+errors, score text, and user details before they enter the queue. Detection is
+heuristic; choose `captureBodies: false` when prompts and outputs must be
+excluded entirely.
+
+Session and user ids need stable grouping. If redaction would change an id, or
+the id exceeds the wire's 128-character limit, the SDK sends a deterministic
+SHA-256 pseudonym of the complete original id instead of a shared marker or
+truncated prefix. Session and user pseudonyms use separate hash domains; safe,
+bounded ids remain unchanged. These are pseudonyms, not anonymous values: the
+hashes are unkeyed, so guessed low-entropy identifiers can be checked against
+them. Prefer opaque identifiers.
+
+With body capture off, span byte counts remain available; input, output and
+messages are omitted, including trace-level bodies. `redact: false` explicitly
+disables masking. Large bodies are truncated to a bounded head and tail.
+Cycles, unsupported values and throwing getters cannot break your code.
+Streamed output is assembled up to a bound; beyond it the span is marked
+truncated and keeps the full byte count.
+
+The queue holds at most 10 MB, including trace envelopes. It sends up to 100
+spans per batch after two seconds, retries transient failures, honours
+`Retry-After`, and splits oversized batches. Oldest queued spans are dropped
+when full. `init()` returns a client with `stats()` to inspect queued and
+dropped spans.
+
+`await flushWithResult(timeoutMs?)` returns `status`, `acceptedSpans`,
+`droppedSpans`, `pendingSpans` and optional `lastError: { code, httpStatus? }`.
+The status is `disabled` without an initialised client, `empty` before any
+recorded delivery, `accepted` only when all queued work has been acknowledged
+without loss, `timeout` while work is pending, or `failed` after any loss.
+
+`sampling.rate` is head sampling: the decision is made per run when it starts,
+so spans of an unsampled run are never sent. While a workspace is over its
+monthly trace allowance the API answers each batch with a lower advisory rate;
+the SDK applies it to new runs, logs a warning once, and returns to the
+configured rate as soon as the hint stops. At three times the allowance the API
+rejects batches with `quota_exceeded` and a `Retry-After`; the SDK retries with
+backoff and eventually drops those spans.
+
+Exit: the queue is flushed on `beforeExit` and, with a two-second bound, on
+`SIGTERM` and `SIGINT`; when nothing else handles the signal the SDK re-raises
+it afterwards so the process still exits. Open automatic runs are ended first.
+Vercel functions receive the final flush through `waitUntil`. On AWS Lambda,
+Netlify and similar hosts `await flush()` before the handler returns. `flush()`
+never rejects and waits up to five seconds by default. Call `shutdown()` only
+when the process is finished: it flushes, stops timers and removes the capture
+hooks.
+
+## Prompt for your coding assistant
+
+Copy this prompt into the AI working in your application repository. Do not
+paste an API key into a prompt; give it only the package version and, for a
+self-hosted API, the API origin.
+
+```text
+Integrate Tracehatch observability into this application. First inspect the
+runtime, server entry point and package manager/lockfile. Preserve our current
+provider, model, credentials, retries and behavior.
+
+Install @tracehatch/sdk@0.3.0 from npm and verify the exact package name and
+version. If the application uses the dashboard-hosted archive instead, preserve
+that installation method and use its versioned SDK URL.
+
+For Node.js, install it in the server package that makes model calls. Read
+TRACEHATCH_API_KEY (and TRACEHATCH_BASE_URL only for a self-hosted API) through our
+existing secret configuration; never print or commit a key or put it in
+client-side/public environment variables. Load the SDK before provider clients
+are created: `node --import @tracehatch/sdk/auto` or
+`import "@tracehatch/sdk/auto"` as the first import of the entry
+file; in Next.js use instrumentation.ts with the nodejs runtime check.
+Model calls, inbound requests, sessions and tool steps are recorded without
+further changes; add trace()/tool()/setSession() only where we want explicit
+naming. Await flush() before short-lived processes and Lambda handlers return.
+
+Start with the connection check from the SDK guide, require status "accepted",
+print the trace id and verify that exact trace in the selected Tracehatch project.
+Keep body capture on unless our data policy says otherwise; init({ captureBodies:
+false }) turns it off. Run focused checks, show the changed files and report
+receipt evidence and anything you could not verify.
+```
+
+## Maintainers
+
+`pnpm --filter @tracehatch/sdk test:package:isolated` rebuilds,
+packs, installs the archive into a clean offline consumer with install scripts
+disabled, and verifies the ESM, CommonJS and auto entries share one client. It
+does not publish anything or call a model or API deployment.
+
+From this repository, `pnpm --filter @tracehatch/sdk sample` runs a
+small agent without any external model dependency. With an API key configured
+(and `TRACEHATCH_BASE_URL` for a local API), it sends a root, a tool and a
+retrieval span to your API. `pnpm --filter @tracehatch/sdk fixture`
+regenerates the API's e2e fixture from the public surface.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Unravel contributors
+
+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,134 @@
+# Tracehatch SDK
+
+Record supported model calls, tool steps and sessions from your Node.js agent.
+See each run in Tracehatch: what called what, where it failed, how long it
+took and what it cost.
+
+## Setup
+
+For guided installation, open your project in Tracehatch and copy its setup command.
+Run it in your existing server application. The installer detects the framework
+and package manager, connects through your browser, and previews its file changes.
+It starts with prompt/output capture disabled and lets you choose what to record.
+
+For manual installation, install in the **server package that makes model calls**:
+
+```sh
+npm install @tracehatch/sdk@0.3.0
+```
+
+The hosted API default is `https://api.tracehatch.com`. Open your project at
+[tracehatch.com](https://tracehatch.com) to view its runs.
+
+For an installation that uses the dashboard-hosted archive:
+
+```sh
+npm install https://tracehatch.com/downloads/tracehatch-sdk-0.3.0.tgz
+```
+
+Create a project API key in Tracehatch and set it in your server's environment:
+
+```dotenv
+TRACEHATCH_API_KEY=your-project-api-key
+```
+
+Use `.env.local` for Next.js. Other Node apps need their existing environment
+loader or Node.js 22+ `--env-file` option; writing an `.env` file alone does not
+load it. Keep the file ignored by Git and restart the server after changing it.
+
+Start a plain Node app with the SDK loaded first:
+
+```sh
+node --import @tracehatch/sdk/auto server.js
+```
+
+or make `import "@tracehatch/sdk/auto"` the first line of your entry
+file (`require("@tracehatch/sdk/auto")` in CommonJS). For a
+self-hosted or local Tracehatch API, also set `TRACEHATCH_BASE_URL`. Hosted Tracehatch
+uses the default API address.
+
+Next.js initializes the SDK in `instrumentation.ts`, beside `app` or `pages`
+(inside `src` when applicable). See `GUIDE.md` for the Node-runtime recipe.
+The automatic import captures bodies by default; use explicit
+`init({ captureBodies: false })` to omit prompts and outputs.
+
+Restart your app, trigger one of its existing AI actions, and open the matching
+run in **Traces**. A successful connection check confirms delivery separately;
+it does not prove that your application initialized the SDK or captured a model.
+
+## What is recorded
+
+- **Model calls** made by any client or framework through `fetch`: OpenAI
+  chat, Responses and embeddings; Anthropic messages; OpenAI-compatible hosts
+  such as Azure OpenAI, Groq, Mistral, Together, OpenRouter, DeepSeek, xAI,
+  Fireworks, Cerebras, Gemini's compatible endpoint and Ollama. Streams are
+  assembled; tokens, time to first token, finish reasons, provider errors and
+  client retries are captured.
+- **Runs**: one per inbound HTTP request that made a model call, or one per
+  agent loop for calls outside a request. A response that asks for tools and
+  the follow-up call with the tool results belong to the same run.
+- **Sessions and users**: the `x-tracehatch-session-id` and `x-tracehatch-user-id`
+  request headers, OpenAI `conversation` / `previous_response_id`, the `user`
+  field or Anthropic `metadata.user_id`, otherwise a fingerprint of the system
+  prompt and first user message, so every turn of a conversation lands in one
+  session.
+- **Tool steps**: tool calls in a response paired with the tool results in the
+  next request become tool spans with arguments, output and duration.
+- **Agent and release**: the nearest `package.json` name (or `TRACEHATCH_AGENT`)
+  and the deployment's commit (platform variables, git `HEAD`, or
+  `TRACEHATCH_RELEASE`).
+
+## Add precision where you want it
+
+```ts
+import { trace, tool, setSession, flush } from "@tracehatch/sdk"
+
+await trace("answer question", async (run) => {
+  setSession("conversation-42")
+  const docs = await tool("search docs", () => search(question))
+  // Model calls made in here are children of this run.
+  const answer = await answerWith(docs)
+  run.score({ name: "confidence", value: 0.9 })
+  return answer
+})
+await flush() // before a short-lived process or Lambda invocation returns
+```
+
+## Check the connection
+
+```js
+import "@tracehatch/sdk/auto"
+import { trace, flushWithResult, shutdown } from "@tracehatch/sdk"
+
+const traceId = await trace("tracehatch-setup-check", (run) => run.id)
+console.log(await flushWithResult(), traceId)
+await shutdown()
+```
+
+`status: "accepted"` means the API stored the batch; open the trace id in your
+project to confirm processing.
+
+## Deploy after local verification
+
+Commit the reviewed initialization, package manifest and lockfile. Create a
+production environment key in Tracehatch and add it to your hosting provider's
+private server settings. Local environment files are not deployed by the
+installer. Redeploy, trigger a real AI action and inspect it in Tracehatch with
+the production environment selected.
+
+## Things to know
+
+- Load the SDK before provider clients are created; they take `fetch` when
+  constructed. A client given its own `fetch` option is not captured.
+- Node.js 18+, ESM, CommonJS and TypeScript, no runtime dependencies. Server
+  code only; never ship the key or the SDK to a browser.
+- Serverless: Vercel functions hand the final flush to `waitUntil`; on AWS
+  Lambda `await flush()` before returning.
+- `init({ captureBodies: false })` records sizes and usage without prompts or
+  outputs. Built-in redaction masks common secrets and personal data before
+  send, but it can miss values.
+
+Full configuration, capture rules and provider details are in `GUIDE.md`,
+included in the installed package.
+
+MIT licensed.

package/dist/auto.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkU5REKR34_cjs=require('./chunk-U5REKR34.cjs');chunkU5REKR34_cjs.a.client||chunkU5REKR34_cjs.m();//# sourceMappingURL=auto.cjs.map
+//# sourceMappingURL=auto.cjs.map

package/dist/auto.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/auto.ts"],"names":["state","init"],"mappings":"mEASKA,mBAAAA,CAAM,QAAQC,mBAAAA,EAAK","file":"auto.cjs","sourcesContent":["/**\n * `@tracehatch/sdk/auto`: import first (or `node --import`) and\n * every model call, inbound request and tool step is recorded with the\n * settings in `TRACEHATCH_API_KEY`, `TRACEHATCH_BASE_URL`, `TRACEHATCH_AGENT` and\n * `TRACEHATCH_RELEASE`. An explicit `init()` made earlier is kept.\n */\nimport { state } from \"./context.js\"\nimport { init } from \"./init.js\"\n\nif (!state.client) init()\n"]}

package/dist/auto.d.cts

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

package/dist/auto.d.ts

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

package/dist/auto.js

@@ -0,0 +1,2 @@
+import {a,m}from'./chunk-KHVJY566.js';a.client||m();//# sourceMappingURL=auto.js.map
+//# sourceMappingURL=auto.js.map

package/dist/auto.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/auto.ts"],"names":["state","init"],"mappings":"sCASKA,CAAAA,CAAM,QAAQC,CAAAA,EAAK","file":"auto.js","sourcesContent":["/**\n * `@tracehatch/sdk/auto`: import first (or `node --import`) and\n * every model call, inbound request and tool step is recorded with the\n * settings in `TRACEHATCH_API_KEY`, `TRACEHATCH_BASE_URL`, `TRACEHATCH_AGENT` and\n * `TRACEHATCH_RELEASE`. An explicit `init()` made earlier is kept.\n */\nimport { state } from \"./context.js\"\nimport { init } from \"./init.js\"\n\nif (!state.client) init()\n"]}