@datagrout/conduit 0.1.0 → 0.2.0

package/dist/index.mjs

@@ -735,6 +735,304 @@ function saveIdentity(identity, directory = DEFAULT_IDENTITY_DIR) {
   return result;
 }
 
+// src/namespaces/prism.ts
+var PrismNamespace = class {
+  /** @internal */
+  constructor(callDg, warn) {
+    this.callDg = callDg;
+    this.warn = warn;
+  }
+  /** AI-driven data transformation (`data-grout/prism.refract`). */
+  async refract(options) {
+    this.warn("prism.refract");
+    const params = {
+      goal: options.goal,
+      payload: options.payload
+    };
+    if (options.verbose !== void 0) params.verbose = options.verbose;
+    if (options.chart !== void 0) params.chart = options.chart;
+    return this.callDg("prism.refract", params);
+  }
+  /** AI-driven charting (`data-grout/prism.chart`). */
+  async chart(options) {
+    this.warn("prism.chart");
+    const params = {
+      goal: options.goal,
+      payload: options.payload
+    };
+    if (options.format) params.format = options.format;
+    if (options.chartType) params.chart_type = options.chartType;
+    if (options.title) params.title = options.title;
+    if (options.xLabel) params.x_label = options.xLabel;
+    if (options.yLabel) params.y_label = options.yLabel;
+    if (options.width !== void 0) params.width = options.width;
+    if (options.height !== void 0) params.height = options.height;
+    return this.callDg("prism.chart", params);
+  }
+  /** Generate a document toward a natural-language goal (`data-grout/prism.render`). */
+  async render(options) {
+    this.warn("prism.render");
+    const { goal, format = "markdown", payload, sections, ...rest } = options;
+    const params = { goal, format, ...rest };
+    if (payload !== void 0) params.payload = payload;
+    if (sections !== void 0) params.sections = sections;
+    return this.callDg("prism.render", params);
+  }
+  /** Convert content to another format without LLM (`data-grout/prism.export`). */
+  async export(options) {
+    this.warn("prism.export");
+    const { content, format, ...rest } = options;
+    const params = { content, format, ...rest };
+    return this.callDg("prism.export", params);
+  }
+  /** Semantic type transformation (`data-grout/prism.focus`). */
+  async focus(options) {
+    this.warn("prism.focus");
+    const params = {
+      data: options.data,
+      source_type: options.sourceType,
+      target_type: options.targetType,
+      ...options.sourceAnnotations && { source_annotations: options.sourceAnnotations },
+      ...options.targetAnnotations && { target_annotations: options.targetAnnotations },
+      ...options.context && { context: options.context }
+    };
+    return this.callDg("prism.focus", params);
+  }
+};
+
+// src/namespaces/logic.ts
+var LogicNamespace = class {
+  /** @internal */
+  constructor(callDg, warn) {
+    this.callDg = callDg;
+    this.warn = warn;
+  }
+  async remember(statementOrOptions, optionsArg) {
+    let statement;
+    let opts;
+    if (typeof statementOrOptions === "string") {
+      statement = statementOrOptions;
+      opts = optionsArg;
+    } else {
+      opts = statementOrOptions;
+      statement = opts.statement;
+    }
+    if (!statement && !opts?.facts?.length) {
+      throw new InvalidConfigError("remember() requires either a statement or facts");
+    }
+    const params = { tag: opts?.tag ?? "default" };
+    if (opts?.facts) {
+      params.facts = opts.facts;
+    } else {
+      params.statement = statement;
+    }
+    return this.callDg("logic.remember", params);
+  }
+  async query(questionOrOptions, optionsArg) {
+    let question;
+    let opts;
+    if (typeof questionOrOptions === "string") {
+      question = questionOrOptions;
+      opts = optionsArg;
+    } else {
+      opts = questionOrOptions;
+      question = opts.question;
+    }
+    if (!question && !opts?.patterns?.length) {
+      throw new InvalidConfigError("query() requires either a question or patterns");
+    }
+    const params = { limit: opts?.limit ?? 50 };
+    if (opts?.patterns) {
+      params.patterns = opts.patterns;
+    } else {
+      params.question = question;
+    }
+    return this.callDg("logic.query", params);
+  }
+  /** Retract facts from the logic cell (`data-grout/logic.forget`). */
+  async forget(options) {
+    if (!options.handles?.length && !options.pattern) {
+      throw new InvalidConfigError("forget() requires either handles or pattern");
+    }
+    const params = {};
+    if (options.handles) params.handles = options.handles;
+    if (options.pattern) params.pattern = options.pattern;
+    return this.callDg("logic.forget", params);
+  }
+  /** Reflect on the logic cell (`data-grout/logic.reflect`). */
+  async reflect(options) {
+    const params = { summary_only: options?.summaryOnly ?? false };
+    if (options?.entity) params.entity = options.entity;
+    return this.callDg("logic.reflect", params);
+  }
+  /** Add a constraint rule (`data-grout/logic.constrain`). */
+  async constrain(rule, options) {
+    const params = { rule, tag: options?.tag ?? "constraint" };
+    return this.callDg("logic.constrain", params);
+  }
+  /** Hydrate the logic cell from external data (`data-grout/logic.hydrate`). */
+  async hydrate(params) {
+    this.warn("logic.hydrate");
+    return this.callDg("logic.hydrate", params);
+  }
+  /** Export the logic cell contents (`data-grout/logic.export`). */
+  async exportCell(params = {}) {
+    this.warn("logic.export");
+    return this.callDg("logic.export", params);
+  }
+  /** Import facts into the logic cell (`data-grout/logic.import`). */
+  async importCell(params) {
+    this.warn("logic.import");
+    return this.callDg("logic.import", params);
+  }
+  /** Tabulate logic cell contents (`data-grout/logic.tabulate`). */
+  async tabulate(params = {}) {
+    this.warn("logic.tabulate");
+    return this.callDg("logic.tabulate", params);
+  }
+  /** Manage hypothetical worlds (`data-grout/logic.worlds`). */
+  async worlds(params) {
+    this.warn("logic.worlds");
+    return this.callDg("logic.worlds", params);
+  }
+};
+
+// src/namespaces/warden.ts
+var WardenNamespace = class {
+  /** @internal */
+  constructor(callDg, warn) {
+    this.callDg = callDg;
+    this.warn = warn;
+  }
+  /** Run a canary safety check (`data-grout/warden.canary`). */
+  async canary(params) {
+    this.warn("warden.canary");
+    return this.callDg("warden.canary", params);
+  }
+  /** Verify intent before executing an action (`data-grout/warden.intent`). */
+  async verifyIntent(params) {
+    this.warn("warden.intent");
+    return this.callDg("warden.intent", params);
+  }
+  /** Adjudicate a dispute or ambiguity (`data-grout/warden.adjudicate`). */
+  async adjudicate(params) {
+    this.warn("warden.adjudicate");
+    return this.callDg("warden.adjudicate", params);
+  }
+  /** Multi-model ensemble consensus check (`data-grout/warden.ensemble`). */
+  async ensemble(params) {
+    this.warn("warden.ensemble");
+    return this.callDg("warden.ensemble", params);
+  }
+};
+
+// src/namespaces/deliverables.ts
+var DeliverablesNamespace = class {
+  /** @internal */
+  constructor(callDg, warn) {
+    this.callDg = callDg;
+    this.warn = warn;
+  }
+  /** Register a work product (`data-grout/deliverables.register`). */
+  async register(params) {
+    this.warn("deliverables.register");
+    return this.callDg("deliverables.register", params);
+  }
+  /** List deliverables with optional semantic search (`data-grout/deliverables.list`). */
+  async list(params = {}) {
+    this.warn("deliverables.list");
+    return this.callDg("deliverables.list", params);
+  }
+  /** Get a specific deliverable by reference (`data-grout/deliverables.get`). */
+  async get(refId) {
+    this.warn("deliverables.get");
+    return this.callDg("deliverables.get", { ref: refId });
+  }
+};
+
+// src/namespaces/ephemerals.ts
+var EphemeralsNamespace = class {
+  /** @internal */
+  constructor(callDg, warn) {
+    this.callDg = callDg;
+    this.warn = warn;
+  }
+  /** List cached results (`data-grout/ephemerals.list`). */
+  async list(params = {}) {
+    this.warn("ephemerals.list");
+    return this.callDg("ephemerals.list", params);
+  }
+  /** Inspect a specific cache entry (`data-grout/ephemerals.inspect`). */
+  async inspect(cacheRef) {
+    this.warn("ephemerals.inspect");
+    return this.callDg("ephemerals.inspect", { cache_ref: cacheRef });
+  }
+};
+
+// src/namespaces/flow.ts
+var FlowNamespace = class {
+  /** @internal */
+  constructor(callDg, warn) {
+    this.callDg = callDg;
+    this.warn = warn;
+  }
+  /** Execute a multi-step workflow plan (`data-grout/flow.into`). */
+  async run(options) {
+    this.warn("flow.into");
+    const params = {
+      plan: options.plan,
+      validate_ctc: options.validateCtc ?? true,
+      save_as_skill: options.saveAsSkill ?? false
+    };
+    if (options.inputData) params.input_data = options.inputData;
+    return this.callDg("flow.into", params);
+  }
+  /** Conditional dispatch with predicate-based branching (`data-grout/flow.route`). */
+  async route(options) {
+    this.warn("flow.route");
+    const { branches, payload, cacheRef, else: elseTarget, ...rest } = options;
+    const params = { branches, ...rest };
+    if (payload !== void 0) params.payload = payload;
+    if (cacheRef !== void 0) params.cache_ref = cacheRef;
+    if (elseTarget !== void 0) params.else = elseTarget;
+    return this.callDg("flow.route", params);
+  }
+  /** Pause workflow for human approval (`data-grout/flow.request-approval`). */
+  async requestApproval(options) {
+    this.warn("flow.request-approval");
+    const { action, details, reason, context, ...rest } = options;
+    const params = { action, ...rest };
+    if (details !== void 0) params.details = details;
+    if (reason !== void 0) params.reason = reason;
+    if (context !== void 0) params.context = context;
+    return this.callDg("flow.request-approval", params);
+  }
+  /** Request user clarification for missing fields (`data-grout/flow.request-feedback`). */
+  async requestFeedback(options) {
+    this.warn("flow.request-feedback");
+    const { missing_fields, reason, ...rest } = options;
+    const params = { missing_fields, reason, ...rest };
+    return this.callDg("flow.request-feedback", params);
+  }
+  /** List recent tool executions (`data-grout/inspect.execution-history`). */
+  async history(options = {}) {
+    this.warn("inspect.execution-history");
+    const params = {
+      limit: options.limit ?? 50,
+      offset: options.offset ?? 0,
+      refractions_only: options.refractions_only ?? false,
+      ...options
+    };
+    if (options.status !== void 0) params.status = options.status;
+    return this.callDg("inspect.execution-history", params);
+  }
+  /** Get details for a specific execution (`data-grout/inspect.execution-details`). */
+  async details(executionId) {
+    this.warn("inspect.execution-details");
+    return this.callDg("inspect.execution-details", { execution_id: executionId });
+  }
+};
+
 // src/client.ts
 var GuidedSession = class {
   client;
@@ -942,6 +1240,35 @@ var Client2 = class _Client {
       }
     }
   }
+  // ===== Namespace Accessors =====
+  callDgTool = async (tool, params) => {
+    this.ensureInitialized();
+    return this.sendWithRetry(() => this.transport.callTool(`data-grout/${tool}`, params));
+  };
+  /** Data transformation, charting, rendering, and type bridging. */
+  get prism() {
+    return new PrismNamespace(this.callDgTool, (m) => this.warnIfNotDg(m));
+  }
+  /** Persistent agent memory backed by a Prolog logic cell. */
+  get logic() {
+    return new LogicNamespace(this.callDgTool, (m) => this.warnIfNotDg(m));
+  }
+  /** Safety gates, intent verification, and multi-model consensus. */
+  get warden() {
+    return new WardenNamespace(this.callDgTool, (m) => this.warnIfNotDg(m));
+  }
+  /** Work product registration, listing, and retrieval. */
+  get deliverables() {
+    return new DeliverablesNamespace(this.callDgTool, (m) => this.warnIfNotDg(m));
+  }
+  /** Cache listing and inspection. */
+  get ephemerals() {
+    return new EphemeralsNamespace(this.callDgTool, (m) => this.warnIfNotDg(m));
+  }
+  /** Multi-step orchestration, routing, approvals, and execution history. */
+  get flow() {
+    return new FlowNamespace(this.callDgTool, (m) => this.warnIfNotDg(m));
+  }
   // ===== Standard MCP API (Drop-in Compatible) =====
   /**
    * List all tools exposed by the connected MCP server.
@@ -1162,60 +1489,6 @@ var Client2 = class _Client {
     };
     return new GuidedSession(this, state);
   }
-  /**
-   * Execute a pre-planned sequence of tool calls (a "flow") through the
-   * DataGrout gateway.
-   *
-   * JSON-RPC method: `tools/call` → `data-grout/flow.into`
-   *
-   * @param options.plan          - Ordered list of tool call descriptors.
-   * @param options.validateCtc   - Validate each call against its CTC schema (default: `true`).
-   * @param options.saveAsSkill   - Persist the flow as a reusable skill (default: `false`).
-   * @param options.inputData     - Runtime input data for the flow.
-   */
-  async flowInto(options) {
-    this.ensureInitialized();
-    this.warnIfNotDg("flowInto");
-    const params = {
-      plan: options.plan,
-      validate_ctc: options.validateCtc ?? true,
-      save_as_skill: options.saveAsSkill ?? false
-    };
-    if (options.inputData) {
-      params.input_data = options.inputData;
-    }
-    return this.sendWithRetry(
-      () => this.transport.callTool("data-grout/flow.into", params)
-    );
-  }
-  /**
-   * Transform data from one annotated type to another using the DataGrout
-   * Prism semantic mapping engine.
-   *
-   * JSON-RPC method: `tools/call` → `data-grout/prism.focus`
-   *
-   * @param options.data               - Source payload to transform.
-   * @param options.sourceType         - Semantic type of the source data.
-   * @param options.targetType         - Desired semantic type for the output.
-   * @param options.sourceAnnotations  - Additional schema hints for the source.
-   * @param options.targetAnnotations  - Additional schema hints for the target.
-   * @param options.context            - Free-text context to guide the mapping.
-   */
-  async prismFocus(options) {
-    this.ensureInitialized();
-    this.warnIfNotDg("prismFocus");
-    const params = {
-      data: options.data,
-      source_type: options.sourceType,
-      target_type: options.targetType,
-      ...options.sourceAnnotations && { source_annotations: options.sourceAnnotations },
-      ...options.targetAnnotations && { target_annotations: options.targetAnnotations },
-      ...options.context && { context: options.context }
-    };
-    return this.sendWithRetry(
-      () => this.transport.callTool("data-grout/prism.focus", params)
-    );
-  }
   /**
    * Generate an execution plan for a goal using DataGrout's planning engine.
    *
@@ -1255,126 +1528,6 @@ var Client2 = class _Client {
       () => this.transport.callTool("data-grout/discovery.plan", params)
     );
   }
-  /**
-   * Analyse and summarise a payload using the DataGrout Prism refraction engine.
-   *
-   * JSON-RPC method: `tools/call` → `data-grout/prism.refract`
-   *
-   * @param options.goal    - Description of what to extract or summarise.
-   * @param options.payload - Input data to analyse (any JSON-serializable value).
-   * @param options.verbose - Include detailed processing trace in the response.
-   * @param options.chart   - Also generate a chart representation.
-   */
-  async refract(options) {
-    this.ensureInitialized();
-    this.warnIfNotDg("refract");
-    const params = {
-      goal: options.goal,
-      payload: options.payload
-    };
-    if (options.verbose !== void 0) params.verbose = options.verbose;
-    if (options.chart !== void 0) params.chart = options.chart;
-    return this.sendWithRetry(
-      () => this.transport.callTool("data-grout/prism.refract", params)
-    );
-  }
-  /**
-   * Generate a chart from a data payload using the DataGrout Prism engine.
-   *
-   * JSON-RPC method: `tools/call` → `data-grout/prism.chart`
-   *
-   * @param options.goal      - What the chart should visualise.
-   * @param options.payload   - Input data (any JSON-serializable value).
-   * @param options.format    - Output format (e.g. `"png"`, `"svg"`).
-   * @param options.chartType - Chart type (e.g. `"bar"`, `"line"`, `"pie"`).
-   * @param options.title     - Chart title.
-   * @param options.xLabel    - X-axis label.
-   * @param options.yLabel    - Y-axis label.
-   * @param options.width     - Chart width in pixels.
-   * @param options.height    - Chart height in pixels.
-   */
-  async chart(options) {
-    this.ensureInitialized();
-    this.warnIfNotDg("chart");
-    const params = {
-      goal: options.goal,
-      payload: options.payload
-    };
-    if (options.format) params.format = options.format;
-    if (options.chartType) params.chart_type = options.chartType;
-    if (options.title) params.title = options.title;
-    if (options.xLabel) params.x_label = options.xLabel;
-    if (options.yLabel) params.y_label = options.yLabel;
-    if (options.width !== void 0) params.width = options.width;
-    if (options.height !== void 0) params.height = options.height;
-    return this.sendWithRetry(
-      () => this.transport.callTool("data-grout/prism.chart", params)
-    );
-  }
-  /**
-   * Generate a document toward a natural-language goal.
-   * Supported formats: markdown, html, pdf, json.
-   */
-  async render(options) {
-    this.ensureInitialized();
-    this.warnIfNotDg("render");
-    const { goal, format = "markdown", payload, sections, ...rest } = options;
-    const params = { goal, format, ...rest };
-    if (payload !== void 0) params.payload = payload;
-    if (sections !== void 0) params.sections = sections;
-    return this.sendWithRetry(() => this.transport.callTool("data-grout/prism.render", params));
-  }
-  /**
-   * Convert content to another format (no LLM). Supports csv, xlsx, pdf, json, html, markdown, etc.
-   */
-  async export(options) {
-    this.ensureInitialized();
-    this.warnIfNotDg("export");
-    const { content, format, ...rest } = options;
-    const params = { content, format, ...rest };
-    return this.sendWithRetry(() => this.transport.callTool("data-grout/prism.export", params));
-  }
-  /**
-   * Pause workflow for human approval. Use for destructive or policy-gated actions.
-   */
-  async requestApproval(options) {
-    this.ensureInitialized();
-    this.warnIfNotDg("requestApproval");
-    const { action, details, reason, context, ...rest } = options;
-    const params = { action, ...rest };
-    if (details !== void 0) params.details = details;
-    if (reason !== void 0) params.reason = reason;
-    if (context !== void 0) params.context = context;
-    return this.sendWithRetry(() => this.transport.callTool("data-grout/flow.request-approval", params));
-  }
-  /**
-   * Request user clarification for missing fields. Pauses until user provides values.
-   */
-  async requestFeedback(options) {
-    this.ensureInitialized();
-    this.warnIfNotDg("requestFeedback");
-    const { missing_fields, reason, ...rest } = options;
-    const params = { missing_fields, reason, ...rest };
-    return this.sendWithRetry(() => this.transport.callTool("data-grout/flow.request-feedback", params));
-  }
-  /**
-   * List recent tool executions for the current server.
-   */
-  async executionHistory(options = {}) {
-    this.ensureInitialized();
-    this.warnIfNotDg("executionHistory");
-    const params = { limit: options.limit ?? 50, offset: options.offset ?? 0, refractions_only: options.refractions_only ?? false, ...options };
-    if (options.status !== void 0) params.status = options.status;
-    return this.sendWithRetry(() => this.transport.callTool("data-grout/inspect.execution-history", params));
-  }
-  /**
-   * Get details and transcript for a specific execution.
-   */
-  async executionDetails(executionId) {
-    this.ensureInitialized();
-    this.warnIfNotDg("executionDetails");
-    return this.sendWithRetry(() => this.transport.callTool("data-grout/inspect.execution-details", { execution_id: executionId }));
-  }
   /**
    * Call any DataGrout first-party tool by its short name.
    *
@@ -1391,119 +1544,6 @@ var Client2 = class _Client {
     const method = `data-grout/${toolShortName}`;
     return this.sendWithRetry(() => this.transport.callTool(method, params));
   }
-  async remember(statementOrOptions, optionsArg) {
-    this.ensureInitialized();
-    let statement;
-    let opts;
-    if (typeof statementOrOptions === "string") {
-      statement = statementOrOptions;
-      opts = optionsArg;
-    } else {
-      opts = statementOrOptions;
-      statement = opts.statement;
-    }
-    if (!statement && !opts?.facts?.length) {
-      throw new InvalidConfigError("remember() requires either a statement or facts");
-    }
-    const params = {
-      tag: opts?.tag ?? "default"
-    };
-    if (opts?.facts) {
-      params.facts = opts.facts;
-    } else {
-      params.statement = statement;
-    }
-    return this.sendWithRetry(
-      () => this.transport.callTool("data-grout/logic.remember", params)
-    );
-  }
-  async queryCell(questionOrOptions, optionsArg) {
-    this.ensureInitialized();
-    let question;
-    let opts;
-    if (typeof questionOrOptions === "string") {
-      question = questionOrOptions;
-      opts = optionsArg;
-    } else {
-      opts = questionOrOptions;
-      question = opts.question;
-    }
-    if (!question && !opts?.patterns?.length) {
-      throw new InvalidConfigError("queryCell() requires either a question or patterns");
-    }
-    const params = {
-      limit: opts?.limit ?? 50
-    };
-    if (opts?.patterns) {
-      params.patterns = opts.patterns;
-    } else {
-      params.question = question;
-    }
-    return this.sendWithRetry(
-      () => this.transport.callTool("data-grout/logic.query", params)
-    );
-  }
-  /**
-   * Retract facts from the agent's logic cell.
-   *
-   * Throws `InvalidConfigError` if neither `handles` nor `pattern` is provided.
-   *
-   * JSON-RPC method: `tools/call` → `data-grout/logic.forget`
-   *
-   * @param options.handles - Specific fact handles to retract.
-   * @param options.pattern - Natural language pattern — retract all matching facts.
-   */
-  async forget(options) {
-    this.ensureInitialized();
-    if (!options.handles?.length && !options.pattern) {
-      throw new InvalidConfigError("forget() requires either handles or pattern");
-    }
-    const params = {};
-    if (options.handles) params.handles = options.handles;
-    if (options.pattern) params.pattern = options.pattern;
-    return this.sendWithRetry(
-      () => this.transport.callTool("data-grout/logic.forget", params)
-    );
-  }
-  /**
-   * Reflect on the agent's logic cell — returns a full snapshot or a
-   * per-entity view of all stored facts.
-   *
-   * JSON-RPC method: `tools/call` → `data-grout/logic.reflect`
-   *
-   * @param options.entity      - Optional entity name to scope reflection.
-   * @param options.summaryOnly - When `true`, return only counts (default: `false`).
-   */
-  async reflect(options) {
-    this.ensureInitialized();
-    const params = {
-      summary_only: options?.summaryOnly ?? false
-    };
-    if (options?.entity) params.entity = options.entity;
-    return this.sendWithRetry(
-      () => this.transport.callTool("data-grout/logic.reflect", params)
-    );
-  }
-  /**
-   * Store a logical rule or policy in the agent's logic cell.
-   *
-   * Rules are permanent constraints evaluated during `queryCell()` calls.
-   *
-   * JSON-RPC method: `tools/call` → `data-grout/logic.constrain`
-   *
-   * @param rule         - Natural language rule (e.g. `"VIP customers have ARR > $500K"`).
-   * @param options.tag  - Tag/namespace for this constraint (default: `"constraint"`).
-   */
-  async constrain(rule, options) {
-    this.ensureInitialized();
-    const params = {
-      rule,
-      tag: options?.tag ?? "constraint"
-    };
-    return this.sendWithRetry(
-      () => this.transport.callTool("data-grout/logic.constrain", params)
-    );
-  }
   /**
    * Estimate the credit cost of a tool call without executing it.
    *
@@ -1535,8 +1575,41 @@ init_oauth();
 
 // src/types.ts
 function extractMeta(result) {
-  const raw = result?._meta?.datagrout ?? result?._datagrout ?? result?._meta;
-  if (!raw?.receipt) return null;
+  const rich = result?._meta?.datagrout;
+  if (rich?.receipt) {
+    return buildToolMeta(rich);
+  }
+  const legacy = result?._datagrout ?? result?._meta;
+  if (legacy?.receipt) {
+    return buildToolMeta(legacy);
+  }
+  const dg = result?._dg;
+  if (dg) {
+    const credits = dg.credits ?? {};
+    const breakdown = {};
+    if (credits.premium !== void 0) breakdown.premium = credits.premium;
+    if (credits.llm !== void 0) breakdown.llm = credits.llm;
+    return {
+      receipt: {
+        receiptId: "",
+        timestamp: "",
+        estimatedCredits: credits.estimated ?? 0,
+        actualCredits: credits.charged ?? 0,
+        netCredits: credits.charged ?? 0,
+        savings: 0,
+        savingsBonus: 0,
+        balanceAfter: credits.remaining,
+        breakdown,
+        byok: { enabled: false, discountApplied: 0, discountRate: 0 }
+      }
+    };
+  }
+  console.warn(
+    '[conduit] No DataGrout metadata found in tool result. Cost tracking data is unavailable. Enable "Include DG Inline" or "Include DataGrout Metadata" in your server settings.'
+  );
+  return null;
+}
+function buildToolMeta(raw) {
   const r = raw.receipt;
   const receipt = {
     receiptId: r.receipt_id ?? "",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datagrout/conduit",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Production-ready MCP client with mTLS, OAuth 2.1, and semantic discovery",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",