> ## Documentation Index
> Fetch the complete documentation index at: https://docs.impact.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Control captured content in JavaScript

> Choose what Impact records and understand the boundaries for streams, native helpers, credentials, and source locations.

Choose what Impact sends from the application. The SDK observes semantic provider data as the native
client exposes it and applies its policy to the Impact telemetry copy.

## Choose what Impact captures

Content capture is on by default. Use the initialization policy to omit selected categories from Impact telemetry.

```ts theme={null}
await impact.init({
  content: { input: false, output: false, tools: false, retrieval: false, media: false },
});
```

Every omitted setting defaults to `true`. `input` includes instructions and requested schemas. `tools` covers
arguments and results on tool carriers, `retrieval` includes memory content, and `media` controls observed bytes.
The SDK validates and snapshots configuration before activation. Mixed native blocks retain permitted content.
If the SDK can't redact the affected Impact record safely, it drops that record and reports the reason.
The root span or log records the effective policy and omission markers.

If the app returns a tool result as its own request output, that copy follows the output policy. Restrict output too
if it can contain data you want omitted. Vercel AI SDK provider metadata can mix several categories in one opaque
value. Impact captures that value only when all five categories permit capture and the native telemetry settings
permit outputs. Native per-call `recordOutputs: false` or disabled telemetry takes precedence.

Only the Impact copy is projected. Existing customer records, processors and destinations remain untouched. Under a
restriction, unclassified correlated log bodies, error text and free-form feedback are omitted because they can
quote any content category. Numeric feedback and operation identity remain available. Simulation invocation and
Protect inference are separately authorized application work. Their telemetry copies obey this policy.

## Credentials and reference URLs

Impact omits signed or authenticated URLs in recognized media and resource reference fields on its outgoing copies,
including known native JSON mirrors, even under full content capture. Captured messages and typed payloads also replace
recognized authenticated HTTP and relative URLs in prose while retaining surrounding text. Ordinary reference URLs
follow the integration's own reference rules. The Google Models supplement drops the native transport envelope from its
capture, including when an Interaction returns the native response. Known OpenAI and Anthropic MCP credentials are
excluded as well. Apply your own redaction to arbitrary application attributes and customer-owned OpenTelemetry
destinations.

## Stream output and usage

Capture observes semantic stream output only as the native owner and caller expose it. It does not read ahead, call a
model again or turn partial consumption into a completed response. Completion, caller stop, provider error,
cancellation, disconnect and SDK shutdown remain distinct. Terminal identity and usage are known only when the native
path exposes them. Dropping an unclosed stream cannot promise terminal output or usage. When Responses supplies cache-read input or
reasoning output token counts, capture preserves them as subsets of the inclusive input/output totals. Missing
counts remain unknown, and those subsets must not be added to the totals.

Selected Product content includes semantic input, output, system instructions, tool definitions, model, response
identity, finish reason and usage. It does not promise a raw provider request or response envelope, unknown vendor
extensions, or replay of every consumed chunk. Unknown fields emitted by an upstream owner or explicit application capture pass through the telemetry pipeline. See the [integration catalogue](https://docs.impact.ai/sdk/javascript/integrations.md)
for other available fields. The SDK reports overflow and serialization loss.

### OpenAI structured output and helpers

The OpenAI supplement snapshots stored request schema data at call time in `impact.openai.response.schema` and records
the supported request spelling in `impact.openai.response.schema_source` as `text.format.schema` or
`response_format.json_schema.schema`. Request accessors and opaque proxies remain native-client owned. Their values
can be unavailable to capture. Native `APIPromise` shape and helper behavior remain intact, and response parsing
remains lazy. An `asResponse()` body remains untouched
and its output is `unavailable.raw-response`. An unobserved call is settled as unavailable only during bounded SDK
shutdown. Early close before a provider terminal signal retains consumed semantic output within a 1 MiB/2,048-part
supplement bound and records a partial outcome. A consumed terminal signal preserves its actual outcome. Reaching the
bound records `partial.local-limit`. Standard Responses `create` streams observe the shared native source once
through direct iteration, `tee()` and native readable conversion. Capture snapshots each observed item before it
reaches the application, so later mutation cannot rewrite the recorded output. Shutdown retains the already observed
prefix without reading or closing the native stream. Protect-wrapped and resumed `retrieve` tee paths remain unassessed.
This does not retain native chunk replay.

## Trace and log content

Semantic input and output logs use the selected [logger route](https://docs.impact.ai/sdk/javascript/setup.md#use-your-opentelemetry-provider).
Inspect trace and log delivery independently. The Google supplement emits a typed body for content with own
`__proto__` or `constructor` map keys on customer loggers. The Impact destination restores those values to
structured attributes. Other Google content keeps its attribute carrier.

## Record source locations

Automatic source locations require a configured root and source basis:

```ts theme={null}
await impact.init({ callsites: { root: '/srv/my-application', basis: 'git:0123456789abcdef' } });
```

Capture observes up to 32 stack frames at the application boundary and emits a safe relative file, available
function and line. It never scans, reads or uploads source, and never emits the absolute root. Node native callsites
are used when available. The bounded fallback refuses custom stack hooks. Missing frames/mappings are reported as
unavailable. Explicit `sourcePath`/`sourceFunction`/`sourceLine` context overrides automatic location coherently.
Omit the setting when no trustworthy source basis exists, or use `enabled: false` to disable automatic capture.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.