@niadra/sdk 0.1.0 → 0.7.0

package/dist/anthropic.js

@@ -0,0 +1,523 @@
+// src/usage.ts
+var PROVIDER = /^[a-z0-9][a-z0-9_.-]{0,63}$/;
+var MODEL = /^[A-Za-z0-9][A-Za-z0-9_.:/@-]{0,127}$/;
+function get(value, name) {
+  return (typeof value === "object" || typeof value === "function") && value !== null ? value[name] : void 0;
+}
+function count(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : null;
+}
+function tokenCounts(usage) {
+  const read = count(get(usage, "cache_read_input_tokens")) ?? 0;
+  const written = count(get(usage, "cache_creation_input_tokens")) ?? 0;
+  let prompt = count(get(usage, "prompt_tokens"));
+  let cached;
+  if (prompt !== null) {
+    const reported = count(get(get(usage, "prompt_tokens_details"), "cached_tokens"));
+    cached = reported !== null && reported > 0 ? reported : read;
+  } else {
+    const inputs = count(get(usage, "input_tokens"));
+    if (inputs === null) return null;
+    const details = get(usage, "input_tokens_details");
+    if (details !== void 0 && details !== null) {
+      prompt = inputs;
+      cached = count(get(details, "cached_tokens")) ?? 0;
+    } else {
+      prompt = inputs + read + written;
+      cached = read;
+    }
+  }
+  return { prompt_tokens: Math.max(prompt, cached + written), cached_tokens: cached, cache_write_tokens: written };
+}
+function providerOf(model, usage) {
+  const slash = model.indexOf("/");
+  if (slash > 0) return model.slice(0, slash).trim().toLowerCase();
+  const name = model.trim().toLowerCase();
+  if (name.startsWith("claude") || `.${name}`.includes(".anthropic.")) return "anthropic";
+  if (name.startsWith("gemini")) return "google";
+  if (get(usage, "prompt_tokens") === void 0 && get(usage, "cache_read_input_tokens") !== void 0) {
+    return "anthropic";
+  }
+  return "openai";
+}
+function modelUsage(response, options = {}) {
+  try {
+    let usage = get(response, "usage");
+    if (usage === void 0 || usage === null || typeof usage !== "object") usage = response;
+    const counts = tokenCounts(usage);
+    const name = options.model ?? get(response, "model");
+    if (!counts || typeof name !== "string" || !MODEL.test(name)) return null;
+    const provider = (options.provider ?? providerOf(name, usage)).toLowerCase();
+    if (!PROVIDER.test(provider)) return null;
+    return { provider, model: name, ...counts };
+  } catch {
+    return 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 resolveSession(source) {
+  if (typeof source !== "function") return source;
+  try {
+    return source() ?? null;
+  } catch {
+    return 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)
+  }));
+}
+
+// src/integrations/intercept.ts
+var States = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  states = /* @__PURE__ */ new WeakMap();
+  /** The session's state; a new one takes `options` (by default the ones this object was built with). */
+  resolve(source, options = this.options) {
+    const session = resolveSession(source);
+    if (!session) return null;
+    let state = this.states.get(session);
+    if (!state) {
+      state = { bridge: new Bridge(session, options.verify, options.agentMemory), seen: /* @__PURE__ */ new Set() };
+      this.states.set(session, state);
+    }
+    return state;
+  }
+  /** Records the user message at `index` once, however many tool steps send it again. */
+  customer(state, index, text) {
+    if (!(this.options.recordCustomer ?? true) || index < 0 || !text) return;
+    const key = `${String(index)}:${text}`;
+    if (state.seen.has(key)) return;
+    state.seen.add(key);
+    state.bridge.customer(text);
+  }
+  get recordsAgent() {
+    return this.options.recordAgent ?? true;
+  }
+};
+function overlay(target, overrides) {
+  return new Proxy(target, {
+    get(obj, prop) {
+      if (Object.prototype.hasOwnProperty.call(overrides, prop)) return overrides[prop];
+      const value = Reflect.get(obj, prop, obj);
+      return typeof value === "function" ? value.bind(obj) : value;
+    }
+  });
+}
+var Pending = class {
+  constructor(started, finish2) {
+    this.started = started;
+    this.finish = finish2;
+    started.catch(() => void 0);
+  }
+  started;
+  finish;
+  result = null;
+  then(onfulfilled, onrejected) {
+    return this.value().then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.value().catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.value().finally(onfinally);
+  }
+  async withResponse() {
+    const { call } = await this.started;
+    const method = property(call, "withResponse");
+    if (typeof method !== "function") throw new TypeError("this client's calls have no withResponse()");
+    const settled = await method.call(call);
+    if (!isBag(settled)) return settled;
+    return { ...settled, data: this.finish(settled.data) };
+  }
+  async asResponse() {
+    const { call } = await this.started;
+    const method = property(call, "asResponse");
+    if (typeof method !== "function") throw new TypeError("this client's calls have no asResponse()");
+    return method.call(call);
+  }
+  value() {
+    this.result ??= this.started.then(({ call }) => call).then((value) => this.finish(value));
+    return this.result;
+  }
+};
+function observeStream(stream, observe, done, logger) {
+  let finished = false;
+  const finish2 = () => {
+    if (finished) return;
+    finished = true;
+    try {
+      done();
+    } catch (error) {
+      logger.warn(`could not record the model's answer (${errorName(error)})`);
+    }
+  };
+  return new Proxy(stream, {
+    get(target, prop) {
+      if (prop === Symbol.asyncIterator) {
+        return () => {
+          const inner = target[Symbol.asyncIterator]();
+          return {
+            async next() {
+              try {
+                const step = await inner.next();
+                if (step.done) finish2();
+                else {
+                  try {
+                    observe(step.value);
+                  } catch {
+                  }
+                }
+                return step;
+              } catch (error) {
+                finish2();
+                throw error;
+              }
+            },
+            async return(value2) {
+              finish2();
+              return inner.return ? inner.return(value2) : { done: true, value: value2 };
+            }
+          };
+        };
+      }
+      const value = Reflect.get(target, prop, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+function property(value, name) {
+  return isBag(value) ? value[name] : void 0;
+}
+function isBag(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null;
+}
+function isAsyncIterable(value) {
+  return isBag(value) && typeof value[Symbol.asyncIterator] === "function";
+}
+
+// src/integrations/anthropic.ts
+var MAX_BREAKPOINTS = 4;
+function wrapAnthropic(client, session, options = {}) {
+  const states = new States(options);
+  const overrides = {};
+  const messages = property(client, "messages");
+  if (!isBag(messages) || typeof messages.create !== "function") {
+    throw new TypeError("wrapAnthropic() expects an Anthropic client with messages.create");
+  }
+  overrides.messages = overlay(messages, { create: intercept(messages, states, session) });
+  const beta = property(client, "beta");
+  const betaMessages = property(beta, "messages");
+  if (isBag(beta) && isBag(betaMessages) && typeof betaMessages.create === "function") {
+    overrides.beta = overlay(beta, { messages: overlay(betaMessages, { create: intercept(betaMessages, states, session) }) });
+  }
+  return overlay(client, overrides);
+}
+async function anthropicParams(session, body, options = {}) {
+  const state = helperStates.resolve(session, options);
+  return state ? await prepare(state, helperStates, body) : body;
+}
+var helperStates = new States({});
+function recordAnthropic(session, message) {
+  const current = resolveSession(session);
+  if (!current) return;
+  try {
+    const text = textOfBlocks(property(message, "content"));
+    const usage = modelUsage(message);
+    if (text) current.agent(text, usage ? { usage } : {});
+  } catch (error) {
+    current.logger.warn(`could not record the model's answer (${errorName(error)})`);
+  }
+}
+function intercept(messages, states, session) {
+  const create = messages.create.bind(messages);
+  return (body, ...rest) => {
+    const state = states.resolve(session);
+    if (!state || !isBag(body)) return create(body, ...rest);
+    const started = prepare(state, states, body).then((prepared) => ({ call: create(prepared, ...rest) }));
+    return new Pending(started, (value) => finish(state, states, value, body.stream === true));
+  };
+}
+async function prepare(state, states, body) {
+  try {
+    const messages = Array.isArray(body.messages) ? body.messages : null;
+    if (!messages) return body;
+    const last = lastUserWithText(messages);
+    if (last >= 0) states.customer(state, last, textOfContent(property(messages[last], "content")));
+    const read = await state.bridge.read();
+    state.bridge.injected(read.context);
+    return inject(body, messages, read);
+  } catch (error) {
+    state.bridge.logger.warn(`could not inject context (${errorName(error)})`);
+    return body;
+  }
+}
+function inject(body, messages, read) {
+  const next = { ...body };
+  if (read.prefix) {
+    const system = body.system;
+    if (system === void 0 || system === null || system === "") next.system = read.prefix;
+    else if (typeof system === "string") next.system = `${system}
+
+${read.prefix}`;
+    else if (Array.isArray(system)) {
+      const block = { type: "text", text: read.prefix };
+      if (breakpoints(body) > 0 && breakpoints(body) < MAX_BREAKPOINTS) block.cache_control = { type: "ephemeral" };
+      next.system = [...system, block];
+    }
+  }
+  if (read.suffix) {
+    const index = lastIndexOfRole(messages, "user");
+    const message = messages[index];
+    if (isBag(message)) {
+      const content = message.content;
+      const blocks = typeof content === "string" ? [{ type: "text", text: content }] : Array.isArray(content) ? [...content] : [];
+      const copy = [...messages];
+      copy[index] = { ...message, content: [...blocks, { type: "text", text: read.suffix }] };
+      next.messages = copy;
+    }
+  }
+  return next;
+}
+function finish(state, states, value, stream) {
+  if (!states.recordsAgent) return value;
+  try {
+    if (!stream) {
+      const text = textOfBlocks(property(value, "content"));
+      const usage = modelUsage(value);
+      state.bridge.agent(text, usage ? { usage } : {});
+      return value;
+    }
+    if (!isAsyncIterable(value)) return value;
+    const parts = [];
+    let start = null;
+    return observeStream(
+      value,
+      (event) => {
+        const type = property(event, "type");
+        if (type === "message_start") start = property(event, "message");
+        else if (type === "content_block_delta") {
+          const delta = property(event, "delta");
+          if (property(delta, "type") === "text_delta" && typeof property(delta, "text") === "string") parts.push(property(delta, "text"));
+        }
+      },
+      () => {
+        const usage = start ? modelUsage(start) : null;
+        state.bridge.agent(parts.join(""), usage ? { usage } : {});
+      },
+      state.bridge.logger
+    );
+  } catch (error) {
+    state.bridge.logger.warn(`could not capture the model's answer (${errorName(error)})`);
+    return value;
+  }
+}
+function breakpoints(body) {
+  let total = 0;
+  const visit = (value) => {
+    if (Array.isArray(value)) for (const item of value) visit(item);
+    else if (isBag(value)) {
+      if (isBag(value.cache_control)) total++;
+      if (Array.isArray(value.content)) visit(value.content);
+    }
+  };
+  visit(body.system);
+  visit(body.messages);
+  visit(body.tools);
+  return total;
+}
+function lastUserWithText(messages) {
+  for (let index = messages.length - 1; index >= 0; index--) {
+    if (property(messages[index], "role") === "user" && textOfContent(property(messages[index], "content"))) return index;
+  }
+  return -1;
+}
+function lastIndexOfRole(messages, role) {
+  for (let index = messages.length - 1; index >= 0; index--) if (property(messages[index], "role") === role) return index;
+  return -1;
+}
+function textOfContent(content) {
+  return typeof content === "string" ? content : textOfBlocks(content);
+}
+function textOfBlocks(content) {
+  if (!Array.isArray(content)) return "";
+  return content.map((block) => property(block, "type") === "text" && typeof property(block, "text") === "string" ? property(block, "text") : "").filter(Boolean).join("\n");
+}
+
+export { anthropicParams, attestationProof, recordAnthropic, wrapAnthropic };
+//# sourceMappingURL=anthropic.js.map
+//# sourceMappingURL=anthropic.js.map