@niadra/sdk 0.1.1 → 0.7.0

package/dist/openai-agents.d.cts

@@ -0,0 +1,75 @@
+import { Session, AgentInputItem, RunContext, Agent, Runner, FunctionTool } from '@openai/agents';
+import { bt as Conversation } from './client-DsIxZxZk.cjs';
+import { a as ProofSource, A as AgentMemoryOption, b as Session$1 } from './shared-DTPWVlWm.cjs';
+export { P as Proof, c as attestationProof } from './shared-DTPWVlWm.cjs';
+
+/**
+ * Niadra for the OpenAI Agents SDK for JavaScript (`@openai/agents` 0.18).
+ *
+ * - `NiadraSession` is a `Session` for `run(agent, input, { session })`: it keeps the run's items
+ *   in the session you give it (a `MemorySession` by default) and records what the customer said
+ *   and what the agent answered as turns, the same way on every run.
+ * - `niadraInstructions(base, conversation)` makes the agent's instructions dynamic: your text,
+ *   then the agent's notes and the customer's pack, then the suffix.
+ * - `niadraTools(conversation)` is the navigation kit as function tools bound to the customer.
+ * - `niadraRunHooks(runner, conversation)` records handoffs between agents, and with `turns: true` each run
+ *   as a turn record: each tool call with its call id, arguments and result, and each model request with
+ *   its tokens. A run inside a turn in progress (`conversation.turn()` around `runner.run`) records into it.
+ *   A function wrapped with `tool()` inside a tool takes over its call, which is how a replay answers it:
+ *   the Runner runs a tool before any hook could answer for it.
+ *
+ * Fail-open: when Niadra is slow or down, the instructions are yours alone and the run goes on.
+ */
+
+interface NiadraSessionOptions {
+    /** Where the run's items live. Defaults to a new `MemorySession`. */
+    inner?: Session;
+    /** Records what the customer said. Defaults to `true`. */
+    recordCustomer?: boolean;
+    /** Records what the agent answered. Defaults to `true`. */
+    recordAgent?: boolean;
+}
+/**
+ * A `Session` that records the conversation's turns in Niadra while another session keeps the
+ * run's items. Pass it to `run()`: `run(agent, input, { session: new NiadraSession(convo) })`.
+ */
+declare class NiadraSession implements Session {
+    readonly conversation: Session$1;
+    private readonly options;
+    private readonly inner;
+    private readonly bridge;
+    constructor(conversation: Session$1, options?: NiadraSessionOptions);
+    getSessionId(): Promise<string>;
+    getItems(limit?: number): Promise<AgentInputItem[]>;
+    addItems(items: AgentInputItem[]): Promise<void>;
+    popItem(): Promise<AgentInputItem | undefined>;
+    clearSession(): Promise<void>;
+}
+interface NiadraInstructionsOptions {
+    /** What your app proved about the user, recorded once before the first context read. */
+    verify?: ProofSource;
+    /** Puts the agent's own notes before the customer's context. Pass the same to `niadraTools`. */
+    agentMemory?: AgentMemoryOption;
+}
+type InstructionsFunction = (runContext: RunContext<any>, agent: Agent<any, any>) => string | Promise<string>;
+/**
+ * Dynamic instructions: your text, then the agent's notes and the customer's pack, then the
+ * suffix. The Agents SDK builds the system prompt from the instructions alone, so the suffix
+ * closes it rather than the input. Use as `new Agent({ instructions: niadraInstructions(...) })`.
+ */
+declare function niadraInstructions(base: string | InstructionsFunction, session: Session$1, options?: NiadraInstructionsOptions): (...args: Parameters<InstructionsFunction>) => Promise<string>;
+/** The navigation kit as Agents SDK function tools, bound to the session's customer. */
+declare function niadraTools(session: Session$1, options?: {
+    agentMemory?: AgentMemoryOption;
+}): FunctionTool[];
+interface NiadraRunHooksOptions {
+    /** Records each run as a turn, with its tool calls and model requests. Defaults to `false`. */
+    turns?: boolean;
+}
+/**
+ * Records each handoff between agents of a run as a handoff to another agent, and with `turns: true` the
+ * run's turn record. Returns a function that stops listening.
+ */
+declare function niadraRunHooks(runner: Runner, conversation: Conversation, options?: NiadraRunHooksOptions): () => void;
+
+export { AgentMemoryOption, type NiadraInstructionsOptions, type NiadraRunHooksOptions, NiadraSession, type NiadraSessionOptions, ProofSource, Session$1 as Session, niadraInstructions, niadraRunHooks, niadraTools };

package/dist/openai-agents.d.ts

@@ -0,0 +1,75 @@
+import { Session, AgentInputItem, RunContext, Agent, Runner, FunctionTool } from '@openai/agents';
+import { bt as Conversation } from './client-DsIxZxZk.js';
+import { a as ProofSource, A as AgentMemoryOption, b as Session$1 } from './shared-Bb5B59Bu.js';
+export { P as Proof, c as attestationProof } from './shared-Bb5B59Bu.js';
+
+/**
+ * Niadra for the OpenAI Agents SDK for JavaScript (`@openai/agents` 0.18).
+ *
+ * - `NiadraSession` is a `Session` for `run(agent, input, { session })`: it keeps the run's items
+ *   in the session you give it (a `MemorySession` by default) and records what the customer said
+ *   and what the agent answered as turns, the same way on every run.
+ * - `niadraInstructions(base, conversation)` makes the agent's instructions dynamic: your text,
+ *   then the agent's notes and the customer's pack, then the suffix.
+ * - `niadraTools(conversation)` is the navigation kit as function tools bound to the customer.
+ * - `niadraRunHooks(runner, conversation)` records handoffs between agents, and with `turns: true` each run
+ *   as a turn record: each tool call with its call id, arguments and result, and each model request with
+ *   its tokens. A run inside a turn in progress (`conversation.turn()` around `runner.run`) records into it.
+ *   A function wrapped with `tool()` inside a tool takes over its call, which is how a replay answers it:
+ *   the Runner runs a tool before any hook could answer for it.
+ *
+ * Fail-open: when Niadra is slow or down, the instructions are yours alone and the run goes on.
+ */
+
+interface NiadraSessionOptions {
+    /** Where the run's items live. Defaults to a new `MemorySession`. */
+    inner?: Session;
+    /** Records what the customer said. Defaults to `true`. */
+    recordCustomer?: boolean;
+    /** Records what the agent answered. Defaults to `true`. */
+    recordAgent?: boolean;
+}
+/**
+ * A `Session` that records the conversation's turns in Niadra while another session keeps the
+ * run's items. Pass it to `run()`: `run(agent, input, { session: new NiadraSession(convo) })`.
+ */
+declare class NiadraSession implements Session {
+    readonly conversation: Session$1;
+    private readonly options;
+    private readonly inner;
+    private readonly bridge;
+    constructor(conversation: Session$1, options?: NiadraSessionOptions);
+    getSessionId(): Promise<string>;
+    getItems(limit?: number): Promise<AgentInputItem[]>;
+    addItems(items: AgentInputItem[]): Promise<void>;
+    popItem(): Promise<AgentInputItem | undefined>;
+    clearSession(): Promise<void>;
+}
+interface NiadraInstructionsOptions {
+    /** What your app proved about the user, recorded once before the first context read. */
+    verify?: ProofSource;
+    /** Puts the agent's own notes before the customer's context. Pass the same to `niadraTools`. */
+    agentMemory?: AgentMemoryOption;
+}
+type InstructionsFunction = (runContext: RunContext<any>, agent: Agent<any, any>) => string | Promise<string>;
+/**
+ * Dynamic instructions: your text, then the agent's notes and the customer's pack, then the
+ * suffix. The Agents SDK builds the system prompt from the instructions alone, so the suffix
+ * closes it rather than the input. Use as `new Agent({ instructions: niadraInstructions(...) })`.
+ */
+declare function niadraInstructions(base: string | InstructionsFunction, session: Session$1, options?: NiadraInstructionsOptions): (...args: Parameters<InstructionsFunction>) => Promise<string>;
+/** The navigation kit as Agents SDK function tools, bound to the session's customer. */
+declare function niadraTools(session: Session$1, options?: {
+    agentMemory?: AgentMemoryOption;
+}): FunctionTool[];
+interface NiadraRunHooksOptions {
+    /** Records each run as a turn, with its tool calls and model requests. Defaults to `false`. */
+    turns?: boolean;
+}
+/**
+ * Records each handoff between agents of a run as a handoff to another agent, and with `turns: true` the
+ * run's turn record. Returns a function that stops listening.
+ */
+declare function niadraRunHooks(runner: Runner, conversation: Conversation, options?: NiadraRunHooksOptions): () => void;
+
+export { AgentMemoryOption, type NiadraInstructionsOptions, type NiadraRunHooksOptions, NiadraSession, type NiadraSessionOptions, ProofSource, Session$1 as Session, niadraInstructions, niadraRunHooks, niadraTools };

package/dist/openai-agents.js

@@ -0,0 +1,459 @@
+import { MemorySession, tool } from '@openai/agents';
+
+// src/integrations/openai-agents.ts
+
+// src/ids.ts
+var lastMs = -1;
+var counter = 0;
+function randomBytes(length) {
+  const bytes = new Uint8Array(length);
+  const webCrypto = globalThis.crypto;
+  if (webCrypto?.getRandomValues) {
+    webCrypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < length; i++) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  return bytes;
+}
+function uuidv7(now = Date.now()) {
+  let ms = now;
+  if (ms <= lastMs) {
+    ms = lastMs;
+    counter = counter + 1 & 4095;
+    if (counter === 0) ms += 1;
+  } else {
+    counter = (randomBytes(2)[0] ?? 0) & 127;
+  }
+  lastMs = ms;
+  const bytes = randomBytes(16);
+  const high = Math.floor(ms / 2 ** 16);
+  const low = ms % 2 ** 16;
+  bytes[0] = high >>> 24 & 255;
+  bytes[1] = high >>> 16 & 255;
+  bytes[2] = high >>> 8 & 255;
+  bytes[3] = high & 255;
+  bytes[4] = low >>> 8 & 255;
+  bytes[5] = low & 255;
+  bytes[6] = 112 | counter >>> 8 & 15;
+  bytes[7] = counter & 255;
+  bytes[8] = 128 | (bytes[8] ?? 0) & 63;
+  let hex = "";
+  for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+// src/capture/tool.ts
+var RECORDED = /* @__PURE__ */ Symbol.for("niadra.tool");
+function recordedTool(fn) {
+  return typeof fn === "function" ? fn[RECORDED] ?? null : null;
+}
+
+// src/context.ts
+function emptyResult(error) {
+  return { text: "", suffix: "", variables: {}, pack: null, source: "none", response: null, error, constraints: null, state: null, coordination: null };
+}
+
+// src/integrations/shared.ts
+var ATTESTED = { A: "V2", B: "V1", C: "V1" };
+function attestationProof(attestation) {
+  if (!attestation) return null;
+  const value = attestation.trim().toUpperCase();
+  if (value.includes("FAILED") || value.startsWith("NO-")) return null;
+  const letter = value.length === 1 ? value : /PASSED-([ABC])$/.exec(value)?.[1];
+  const level = letter ? ATTESTED[letter] : void 0;
+  return level ? { method: "network_attestation", level } : null;
+}
+function isConversation(session) {
+  return "customer" in session && typeof session.customer === "function";
+}
+function errorName(error) {
+  return error instanceof Error ? error.name : typeof error;
+}
+var Bridge = class {
+  constructor(session, proof, memory = false) {
+    this.session = session;
+    this.proof = proof;
+    this.memory = memory;
+  }
+  session;
+  proof;
+  memory;
+  proving = null;
+  /** `begin()` started the first read of a call: the first `context()` waits for it with `ready()`. */
+  begun = false;
+  opened = false;
+  /**
+   * The context and, when enabled, the agent's notes, read side by side within the same budget.
+   * Never rejects.
+   */
+  async read(options = {}) {
+    const memoryParams = this.memory === false ? null : this.memory === true ? {} : withoutWrite(this.memory);
+    const [context, memory] = await Promise.all([
+      this.context(options),
+      memoryParams ? this.agentMemory(memoryParams, options) : Promise.resolve("")
+    ]);
+    return { context, memory, prefix: [memory, context.text].filter(Boolean).join("\n\n"), suffix: context.suffix };
+  }
+  get logger() {
+    return this.session.logger;
+  }
+  /**
+   * Starts the first read of a call now, in the background, after the proof when one was given (the
+   * pack depends on the level it proves): at call start, so the read runs while the call is set up.
+   * The first `context()` then waits for it within `timeouts.contextVoiceStart`. Never throws.
+   */
+  begin() {
+    const session = this.session;
+    if (!isConversation(session)) return;
+    const start = () => {
+      this.safe("start the first read", () => {
+        this.begun = session.begin();
+      });
+    };
+    if (this.proof === void 0 || this.proof === null) start();
+    else void this.verifyOnce().then(start);
+  }
+  /** Verifies once (when a proof was given), then reads the context. Never rejects. */
+  async context(options = {}) {
+    await this.verifyOnce();
+    try {
+      const session = this.session;
+      if (this.begun && !this.opened && isConversation(session)) {
+        this.opened = true;
+        await session.ready(options.timeout === void 0 ? {} : { timeout: options.timeout });
+      }
+      return await this.session.context(options);
+    } catch (error) {
+      this.logger.warn(`could not read context (${errorName(error)})`);
+      return emptyResult(null);
+    }
+  }
+  /** Records that `context` went into the prompt, unless it was empty for a reason other than the holdout. */
+  injected(context) {
+    if (!context.text && !context.suffix && context.response?.path !== "holdout") return;
+    this.safe("mark the injection", () => {
+      this.session.markInjected(context);
+    });
+  }
+  customer(text, options = {}) {
+    const session = this.session;
+    if (!text.trim() || !isConversation(session)) return;
+    this.safe("record the customer's turn", () => session.customer(text, options));
+  }
+  /** Sends the customer's turn so far, while they speak. In the background; never throws. */
+  prefetch(text) {
+    const session = this.session;
+    if (!text.trim() || !isConversation(session)) return;
+    this.safe("prefetch the turn", () => session.prefetch(text));
+  }
+  agent(text, options = {}) {
+    if (!text.trim()) return;
+    this.safe("record the agent's turn", () => this.session.agent(text, options));
+  }
+  /** Records a transfer. Tasks have no transfer; the call is ignored for them. */
+  async handoff(target, reason) {
+    const session = this.session;
+    if (!isConversation(session)) return;
+    try {
+      await session.handoff(reason ? { target, reason } : { target });
+    } catch (error) {
+      this.logger.warn(`could not record the handoff (${errorName(error)})`);
+    }
+  }
+  async end() {
+    try {
+      await this.session.end();
+    } catch (error) {
+      this.logger.warn(`could not end the session (${errorName(error)})`);
+    }
+  }
+  /** The navigation kit as plain specs (with the agent's memory tools when enabled), or none for a task about an object only. */
+  tools() {
+    let bound;
+    try {
+      const memory = this.memory;
+      bound = this.session.tools(memory === false ? {} : { agentMemory: true, writeAgentMemory: memory !== true && memory.write === true });
+    } catch (error) {
+      this.logger.warn(`could not build the tools (${errorName(error)})`);
+      return [];
+    }
+    return bound ? toolSpecs(bound) : [];
+  }
+  async agentMemory(params, options) {
+    try {
+      const result = await this.session.agentMemory(params, options.timeout === void 0 ? {} : { timeout: options.timeout });
+      return result.text;
+    } catch (error) {
+      this.logger.warn(`could not read the agent's memory (${errorName(error)})`);
+      return "";
+    }
+  }
+  async verifyOnce() {
+    if (this.proof === void 0 || this.proof === null) return;
+    this.proving ??= this.runVerify();
+    await this.proving;
+  }
+  async runVerify() {
+    try {
+      const source = this.proof;
+      const proof = typeof source === "function" ? await source() : source;
+      if (!proof) return;
+      await this.session.verify(proof);
+    } catch (error) {
+      this.logger.warn(`could not record the verification (${errorName(error)})`);
+    }
+  }
+  safe(what, run) {
+    try {
+      run();
+    } catch (error) {
+      this.logger.warn(`could not ${what} (${errorName(error)})`);
+    }
+  }
+};
+function withoutWrite(option) {
+  const { write: _, ...params } = option;
+  return params;
+}
+function toolSpecs(bound) {
+  return bound.definitions.map(({ function: definition }) => ({
+    name: definition.name,
+    description: definition.description,
+    parameters: definition.parameters,
+    execute: (args) => bound.call(definition.name, args)
+  }));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function count(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : null;
+}
+var TurnHooks = class _TurnHooks {
+  constructor(adapter, enabled) {
+    this.adapter = adapter;
+    this.enabled = enabled;
+  }
+  adapter;
+  enabled;
+  /** Runs held open at most; past it the oldest run's turn closes, incomplete (a run whose end never came). */
+  static MAX_OPEN = 100;
+  frames = /* @__PURE__ */ new Map();
+  calls = /* @__PURE__ */ new Map();
+  /** The turn of the run `key`: the session's turn in progress, or a new one of its own. */
+  open(session, key, params = {}) {
+    if (!this.enabled) return void 0;
+    const held = this.frames.get(key);
+    if (held !== void 0) return held.frame;
+    try {
+      const active = session.activeTurn();
+      if (active !== void 0 && !this.owns(active)) {
+        this.frames.set(key, { frame: active, own: false });
+        return active;
+      }
+      const frame = session.openTurn({ ...params, adapter: this.adapter });
+      this.frames.set(key, { frame, own: true });
+      if (this.frames.size > _TurnHooks.MAX_OPEN) {
+        const [oldest] = this.frames.keys();
+        if (oldest !== void 0) {
+          this.frames.get(oldest)?.frame.incomplete();
+          this.close(oldest);
+        }
+      }
+      return frame;
+    } catch (error) {
+      session.logger.warn(`could not open the turn (${errorName(error)})`);
+      return void 0;
+    }
+  }
+  /** The turn of `key`, else the session's turn in progress. */
+  frame(session, key) {
+    if (!this.enabled) return void 0;
+    const held = key === void 0 ? void 0 : this.frames.get(key);
+    const frame = held?.frame ?? session.activeTurn();
+    return frame === void 0 || frame.closed ? void 0 : frame;
+  }
+  has(key) {
+    return this.frames.has(key);
+  }
+  owns(frame) {
+    for (const held of this.frames.values()) if (held.own && held.frame === frame) return true;
+    return false;
+  }
+  /** Ends the run `key`: a turn the adapter opened closes; the calls it left open failed. */
+  close(key, error) {
+    const held = this.frames.get(key);
+    if (held === void 0) return;
+    this.frames.delete(key);
+    for (const [callKey, call] of this.calls) {
+      if (call.frame !== held.frame) continue;
+      this.calls.delete(callKey);
+      if (held.own) call.failed(error ?? "error");
+    }
+    if (held.own) held.frame.close(error);
+  }
+  /** A tool call starting, keyed by `callKey`; `callId` is the provider's id of the call, when there is one. */
+  toolStart(session, callKey, name, args, options = {}) {
+    const frame = this.frame(session, options.frameKey);
+    if (frame === void 0) return;
+    try {
+      this.calls.set(callKey, frame.toolCall(name, args, { callId: options.callId ?? null, adoptable: true }));
+    } catch {
+      frame.incomplete();
+    }
+  }
+  /**
+   * In a replay, how a framework tool the adapter stands in for answers: the recorded result of a call with the
+   * same arguments, or empty (a divergence), never the live tool. `null` outside a replay, and for a function
+   * wrapped with `tool()`, which answers itself.
+   */
+  replayed(session, name, args, fn, frameKey) {
+    const frame = this.enabled ? this.frame(session, frameKey) : session.activeTurn();
+    if (frame?.playback == null || fn !== void 0 && recordedTool(fn) !== null) return null;
+    return frame.playback.answer(name, args, false);
+  }
+  toolEnd(callKey, result, error) {
+    const call = this.calls.get(callKey);
+    if (call === void 0) return;
+    this.calls.delete(callKey);
+    try {
+      if (error !== void 0) call.failed(error);
+      else call.result(result);
+    } catch {
+      call.frame.incomplete();
+    }
+  }
+  /** A model call that ended, with its tokens when the framework reported them. */
+  model(session, model, tokens = {}, frameKey) {
+    const frame = this.frame(session, frameKey);
+    if (frame === void 0) return;
+    try {
+      frame.modelCall(model, { tokensIn: tokens.in ?? null, tokensOut: tokens.out ?? null, tokensCached: tokens.cached ?? 0 });
+    } catch {
+      frame.incomplete();
+    }
+  }
+};
+
+// src/integrations/openai-agents.ts
+var NiadraSession = class {
+  constructor(conversation, options = {}) {
+    this.conversation = conversation;
+    this.options = options;
+    this.inner = options.inner ?? new MemorySession({ sessionId: conversation.id });
+    this.bridge = new Bridge(conversation);
+  }
+  conversation;
+  options;
+  inner;
+  bridge;
+  getSessionId() {
+    return this.inner.getSessionId();
+  }
+  getItems(limit) {
+    return this.inner.getItems(limit);
+  }
+  async addItems(items) {
+    await this.inner.addItems(items);
+    for (const item of items) {
+      if (!isRecord(item)) continue;
+      if (item.role === "user" && (this.options.recordCustomer ?? true)) this.bridge.customer(textOf(item.content));
+      if (item.role === "assistant" && (this.options.recordAgent ?? true)) this.bridge.agent(textOf(item.content));
+    }
+  }
+  popItem() {
+    return this.inner.popItem();
+  }
+  clearSession() {
+    return this.inner.clearSession();
+  }
+};
+function niadraInstructions(base, session, options = {}) {
+  const bridge = new Bridge(session, options.verify, options.agentMemory);
+  return async (runContext, agent) => {
+    const own = typeof base === "function" ? await base(runContext, agent) : base;
+    const read = await bridge.read();
+    bridge.injected(read.context);
+    return [own, read.prefix, read.suffix].filter(Boolean).join("\n\n");
+  };
+}
+function niadraTools(session, options = {}) {
+  return new Bridge(session, void 0, options.agentMemory).tools().map(
+    (spec) => tool({
+      name: spec.name,
+      description: spec.description,
+      // The canonical schemas have optional fields, so the tool is not strict.
+      parameters: spec.parameters,
+      strict: false,
+      execute: async (input) => spec.execute(isRecord(input) ? input : {})
+    })
+  );
+}
+function niadraRunHooks(runner, conversation, options = {}) {
+  const bridge = new Bridge(conversation);
+  const hooks = new TurnHooks("openai-agents", options.turns ?? false);
+  const keys = /* @__PURE__ */ new WeakMap();
+  const keyOf = (context) => {
+    let key = keys.get(context);
+    if (key === void 0) {
+      key = uuidv7();
+      keys.set(context, key);
+    }
+    return key;
+  };
+  const onHandoff = (_context, from, to) => {
+    void bridge.handoff("agent", `${from.name} to ${to.name}`);
+  };
+  const onStart = (context, agent) => {
+    hooks.open(conversation, keyOf(context), { agent: agent.name });
+  };
+  const onToolStart = (context, _agent, tool2, details) => {
+    const call = isRecord(details.toolCall) ? details.toolCall : {};
+    const callId = typeof call.callId === "string" ? call.callId : null;
+    hooks.toolStart(conversation, callId ?? uuidv7(), tool2.name, parsed(call.arguments), { frameKey: keyOf(context), callId });
+  };
+  const onToolEnd = (_context, _agent, _tool, result, details) => {
+    const call = isRecord(details.toolCall) ? details.toolCall : {};
+    if (typeof call.callId === "string") hooks.toolEnd(call.callId, result);
+  };
+  const onEnd = (context, agent) => {
+    const key = keyOf(context);
+    const model = typeof agent.model === "string" ? agent.model : null;
+    const usage = isRecord(context) && isRecord(context.usage) ? context.usage : {};
+    const entries = Array.isArray(usage.requestUsageEntries) ? usage.requestUsageEntries : [];
+    for (const entry of entries) {
+      const details = isRecord(entry.inputTokensDetails) ? entry.inputTokensDetails : {};
+      hooks.model(conversation, model, { in: count(entry.inputTokens), out: count(entry.outputTokens), cached: count(details.cached_tokens) ?? 0 }, key);
+    }
+    hooks.close(key);
+  };
+  runner.on("agent_handoff", onHandoff);
+  runner.on("agent_start", onStart);
+  runner.on("agent_tool_start", onToolStart);
+  runner.on("agent_tool_end", onToolEnd);
+  runner.on("agent_end", onEnd);
+  return () => {
+    runner.off("agent_handoff", onHandoff);
+    runner.off("agent_start", onStart);
+    runner.off("agent_tool_start", onToolStart);
+    runner.off("agent_tool_end", onToolEnd);
+    runner.off("agent_end", onEnd);
+  };
+}
+function parsed(text) {
+  if (typeof text !== "string") return text;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => isRecord(part) && (part.type === "input_text" || part.type === "output_text") && typeof part.text === "string" ? part.text : "").join("");
+}
+
+export { NiadraSession, attestationProof, niadraInstructions, niadraRunHooks, niadraTools };
+//# sourceMappingURL=openai-agents.js.map
+//# sourceMappingURL=openai-agents.js.map