@synapsor/client 0.1.1 → 0.1.3

package/external-db-writeback.mjs

@@ -0,0 +1,266 @@
+function quoteIdentifier(kind, identifier) {
+  const text = String(identifier || "");
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(text)) {
+    throw new Error(`UNSAFE_IDENTIFIER: ${text}`);
+  }
+  return kind === "mysql" ? `\`${text}\`` : `"${text}"`;
+}
+
+function placeholder(kind, index) {
+  return kind === "mysql" ? "?" : `$${index}`;
+}
+
+function assertAllowedColumns(proposal, columns, label) {
+  const allowed = new Set((proposal.allowed_columns || []).map(String));
+  const blocked = columns.filter((column) => !allowed.has(String(column)));
+  if (blocked.length) {
+    throw new Error(`WRITEBACK_COLUMN_NOT_ALLOWED: ${label} ${blocked.join(",")}`);
+  }
+}
+
+export function buildExternalWritebackSql(proposal, { kind = undefined } = {}) {
+  const sourceKind = kind || proposal.source_kind || "postgres";
+  if (!["postgres", "mysql"].includes(sourceKind)) {
+    throw new Error(`UNSUPPORTED_WRITEBACK_KIND: ${sourceKind}`);
+  }
+  const operation = String(proposal.operation || "update").toLowerCase();
+  if (!["update", "insert", "delete"].includes(operation)) {
+    throw new Error(`UNSUPPORTED_WRITEBACK_OPERATION: ${operation}`);
+  }
+  const schema = String(proposal.external_schema || proposal.external_catalog || "");
+  const table = String(proposal.external_table || "");
+  if (!schema || !table) {
+    throw new Error("WRITEBACK_TABLE_REQUIRED: proposal must include external_schema and external_table");
+  }
+  const tableRef = `${quoteIdentifier(sourceKind, schema)}.${quoteIdentifier(sourceKind, table)}`;
+  const changes = proposal.changes && typeof proposal.changes === "object" ? proposal.changes : {};
+  const primaryKey = proposal.primary_key && typeof proposal.primary_key === "object" ? proposal.primary_key : {};
+  const conflict = proposal.conflict && typeof proposal.conflict === "object" ? proposal.conflict : {};
+  const tenantColumn = proposal.tenant_column ? String(proposal.tenant_column) : "";
+  const tenantId = proposal.tenant_id;
+  const conflictColumn = proposal.conflict_column ? String(proposal.conflict_column) : "";
+  const params = [];
+  const where = [];
+
+  function pushParam(value) {
+    params.push(value);
+    return placeholder(sourceKind, params.length);
+  }
+
+  function appendWhereClauses() {
+    for (const column of pkColumns) {
+      where.push(`${quoteIdentifier(sourceKind, column)} = ${pushParam(primaryKey[column])}`);
+    }
+    if (tenantColumn) {
+      assertAllowedColumns(proposal, [tenantColumn], "tenant");
+      where.push(`${quoteIdentifier(sourceKind, tenantColumn)} = ${pushParam(tenantId)}`);
+    }
+    if (conflictColumn && Object.prototype.hasOwnProperty.call(conflict, conflictColumn)) {
+      assertAllowedColumns(proposal, [conflictColumn], "conflict");
+      where.push(`${quoteIdentifier(sourceKind, conflictColumn)} = ${pushParam(conflict[conflictColumn])}`);
+    }
+  }
+
+  if (operation === "insert") {
+    const insertColumns = Object.keys(changes);
+    if (tenantColumn && !insertColumns.includes(tenantColumn)) {
+      insertColumns.push(tenantColumn);
+      changes[tenantColumn] = tenantId;
+    }
+    if (!insertColumns.length) {
+      throw new Error("WRITEBACK_INSERT_VALUES_REQUIRED");
+    }
+    assertAllowedColumns(proposal, insertColumns, "insert");
+    const columnSql = insertColumns.map((column) => quoteIdentifier(sourceKind, column)).join(", ");
+    const valueSql = insertColumns.map((column) => pushParam(changes[column])).join(", ");
+    return {
+      sql: `INSERT INTO ${tableRef} (${columnSql}) VALUES (${valueSql})`,
+      params,
+      operation,
+      expectedRowCount: 1,
+    };
+  }
+
+  const pkColumns = Object.keys(primaryKey);
+  if (!pkColumns.length) {
+    throw new Error("WRITEBACK_PRIMARY_KEY_REQUIRED");
+  }
+  assertAllowedColumns(proposal, pkColumns, "primary_key");
+
+  if (operation === "delete") {
+    appendWhereClauses();
+    return {
+      sql: `DELETE FROM ${tableRef} WHERE ${where.join(" AND ")}`,
+      params,
+      operation,
+      expectedRowCount: 1,
+    };
+  }
+
+  const changeColumns = Object.keys(changes);
+  if (!changeColumns.length) {
+    throw new Error("WRITEBACK_UPDATE_VALUES_REQUIRED");
+  }
+  assertAllowedColumns(proposal, changeColumns, "update");
+  const protectedColumns = new Set([...pkColumns, tenantColumn, conflictColumn].filter(Boolean));
+  const protectedChanges = changeColumns.filter((column) => protectedColumns.has(column));
+  if (protectedChanges.length) {
+    throw new Error(`WRITEBACK_PROTECTED_COLUMN_CHANGE: ${protectedChanges.join(",")}`);
+  }
+  const setSql = changeColumns
+    .map((column) => `${quoteIdentifier(sourceKind, column)} = ${pushParam(changes[column])}`)
+    .join(", ");
+  appendWhereClauses();
+  return {
+    sql: `UPDATE ${tableRef} SET ${setSql} WHERE ${where.join(" AND ")}`,
+    params,
+    operation,
+    expectedRowCount: 1,
+  };
+}
+
+async function request({ baseUrl, apiKey, fetchImpl }, method, path, body) {
+  const response = await fetchImpl(`${baseUrl.replace(/\/+$/, "")}${path}`, {
+    method,
+    headers: {
+      accept: "application/json",
+      authorization: `Bearer ${apiKey}`,
+      ...(body === undefined ? {} : { "content-type": "application/json" }),
+    },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  const text = await response.text();
+  let payload = {};
+  if (text.trim()) {
+    payload = JSON.parse(text);
+  }
+  if (!response.ok || payload.ok === false) {
+    const error = new Error(payload.message || payload.error || `HTTP ${response.status}`);
+    error.payload = payload;
+    throw error;
+  }
+  return payload;
+}
+
+function rowCountFromResult(result) {
+  if (typeof result === "number") return result;
+  if (!result || typeof result !== "object") return 0;
+  return Number(result.rowCount ?? result.affectedRows ?? result.rowsAffected ?? 0);
+}
+
+async function executeWithDb(db, built, proposal, kind) {
+  if (!db) {
+    throw new Error("WRITEBACK_EXECUTOR_REQUIRED: pass execute({sql, params}) or db client");
+  }
+  if (typeof db === "function") {
+    return db({ ...built, proposal, kind });
+  }
+  if (typeof db.execute === "function") {
+    return db.execute(built.sql, built.params);
+  }
+  if (typeof db.query === "function") {
+    return db.query(built.sql, built.params);
+  }
+  throw new Error("WRITEBACK_EXECUTOR_REQUIRED: db must expose execute() or query()");
+}
+
+export function createExternalDbWritebackWorker(options = {}) {
+  const {
+    baseUrl = "https://synapsor.ai",
+    synapsorApiKey = process.env.SYNAPSOR_API_KEY,
+    sourceId = "",
+    sourceName = "",
+    projectId = "",
+    kind = undefined,
+    db = undefined,
+    execute = undefined,
+    fetchImpl = globalThis.fetch,
+    pollIntervalMs = 5000,
+    dryRun = false,
+  } = options;
+  if (!synapsorApiKey) {
+    throw new Error("SYNAPSOR_API_KEY_REQUIRED");
+  }
+  if (!fetchImpl) {
+    throw new Error("FETCH_REQUIRED");
+  }
+  let stopped = false;
+  let timer = null;
+  const client = { baseUrl, apiKey: synapsorApiKey, fetchImpl };
+
+  async function resolveSourceId() {
+    if (sourceId) return sourceId;
+    if (!sourceName) return "";
+    const query = projectId ? `?project_id=${encodeURIComponent(projectId)}` : "";
+    const listed = await request(client, "GET", `/v1/control/external-sources${query}`);
+    const match = (listed.sources || []).find((source) => source.name === sourceName || source.source_id === sourceName);
+    if (!match) throw new Error(`SOURCE_NOT_FOUND: ${sourceName}`);
+    return match.source_id;
+  }
+
+  async function pollOnce() {
+    const resolvedSourceId = await resolveSourceId();
+    const params = new URLSearchParams();
+    if (resolvedSourceId) params.set("source_id", resolvedSourceId);
+    if (projectId) params.set("project_id", projectId);
+    params.set("status", "approved");
+    const listed = await request(client, "GET", `/v1/control/external-writebacks/proposals?${params.toString()}`);
+    const results = [];
+    for (const proposal of listed.proposals || []) {
+      const built = buildExternalWritebackSql(proposal, { kind: kind || proposal.source_kind });
+      if (dryRun) {
+        results.push({ proposal_id: proposal.proposal_id, dryRun: true, ...built });
+        continue;
+      }
+      try {
+        const rawResult = await executeWithDb(execute || db, built, proposal, kind || proposal.source_kind);
+        const affectedRows = rowCountFromResult(rawResult);
+        const status = affectedRows === built.expectedRowCount ? "applied" : "conflict";
+        const reported = await request(
+          client,
+          "POST",
+          `/v1/control/external-writebacks/proposals/${encodeURIComponent(proposal.proposal_id)}/apply-result`,
+          {
+            status,
+            idempotency_key: proposal.idempotency_key,
+            external_commit_metadata: {
+              affected_rows: String(affectedRows),
+              operation: built.operation,
+            },
+          },
+        );
+        results.push({ proposal_id: proposal.proposal_id, status, affectedRows, reported });
+      } catch (error) {
+        await request(
+          client,
+          "POST",
+          `/v1/control/external-writebacks/proposals/${encodeURIComponent(proposal.proposal_id)}/apply-result`,
+          {
+            status: "failed",
+            idempotency_key: proposal.idempotency_key,
+            error: error.message || String(error),
+          },
+        );
+        results.push({ proposal_id: proposal.proposal_id, status: "failed", error: error.message || String(error) });
+      }
+    }
+    return { ok: true, count: results.length, results };
+  }
+
+  async function start() {
+    stopped = false;
+    while (!stopped) {
+      await pollOnce();
+      await new Promise((resolve) => {
+        timer = setTimeout(resolve, pollIntervalMs);
+      });
+    }
+  }
+
+  function stop() {
+    stopped = true;
+    if (timer) clearTimeout(timer);
+  }
+
+  return { pollOnce, start, stop };
+}

package/generated-contract.mjs

@@ -1,6 +1,6 @@
 // Generated by tools/generate_openapi_sdk_contract.py. Do not edit by hand.
 export const PROTOCOL_VERSION = "v1";
-export const CONTRACT_SHA256 = "af3ae249f90c9d7dd7d424890c8a9d37e1c6c8c024cd83341f882c5bac8c389d";
+export const CONTRACT_SHA256 = "482f2e07b65471b6709045fd3be3c14d678671c22a2f9cefa8e9d5b7e2551cbb";
 export const OPENAPI_OPERATIONS = Object.freeze({
   "approveAgentProposal": {
     "method": "POST",
@@ -26,6 +26,14 @@ export const OPENAPI_OPERATIONS = Object.freeze({
     "python_method": "cancel_hybrid_reembed_job",
     "request_schema": "#/components/schemas/HybridReembedJobActionRequest"
   },
+  "clearAdminTenantBudget": {
+    "method": "POST",
+    "node_method": "clearAdminTenantBudget",
+    "path": "/v1/admin/tenant-budgets/clear",
+    "public": false,
+    "python_method": "clear_admin_tenant_budget",
+    "request_schema": null
+  },
   "commitAgentProposal": {
     "method": "POST",
     "node_method": "commitWrite",
@@ -122,6 +130,30 @@ export const OPENAPI_OPERATIONS = Object.freeze({
     "python_method": "shutdown",
     "request_schema": null
   },
+  "postAgentAdapter": {
+    "method": "POST",
+    "node_method": "createAgentAdapter",
+    "path": "/v1/agent/adapters",
+    "public": false,
+    "python_method": "create_agent_adapter",
+    "request_schema": null
+  },
+  "postAgentAdapterToolCall": {
+    "method": "POST",
+    "node_method": "callAdapterTool",
+    "path": "/v1/agent/adapters/call-tool",
+    "public": false,
+    "python_method": "call_adapter_tool",
+    "request_schema": null
+  },
+  "postAgentAdapterTools": {
+    "method": "POST",
+    "node_method": "adapterTools",
+    "path": "/v1/agent/adapters/tools",
+    "public": false,
+    "python_method": "adapter_tools",
+    "request_schema": null
+  },
   "postAgentCapabilities": {
     "method": "POST",
     "node_method": "listCapabilities",
@@ -130,6 +162,38 @@ export const OPENAPI_OPERATIONS = Object.freeze({
     "python_method": "list_capabilities",
     "request_schema": "#/components/schemas/CapabilityDiscoveryRequest"
   },
+  "postAgentEval": {
+    "method": "POST",
+    "node_method": "createAgentEval",
+    "path": "/v1/agent/evals",
+    "public": false,
+    "python_method": "create_agent_eval",
+    "request_schema": null
+  },
+  "postAgentEvalDiff": {
+    "method": "POST",
+    "node_method": "diffAgentEval",
+    "path": "/v1/agent/evals/diff",
+    "public": false,
+    "python_method": "diff_agent_eval",
+    "request_schema": null
+  },
+  "postAgentEvalFailures": {
+    "method": "POST",
+    "node_method": "agentEvalFailures",
+    "path": "/v1/agent/evals/failures",
+    "public": false,
+    "python_method": "agent_eval_failures",
+    "request_schema": null
+  },
+  "postAgentEvalRun": {
+    "method": "POST",
+    "node_method": "runAgentEval",
+    "path": "/v1/agent/evals/run",
+    "public": false,
+    "python_method": "run_agent_eval",
+    "request_schema": null
+  },
   "postAgentInvoke": {
     "method": "POST",
     "node_method": "invokeAgentCapability",
@@ -146,6 +210,62 @@ export const OPENAPI_OPERATIONS = Object.freeze({
     "python_method": "memory_command",
     "request_schema": "#/components/schemas/AgentMemoryRequest"
   },
+  "postAgentRun": {
+    "method": "POST",
+    "node_method": "beginAgentRun",
+    "path": "/v1/agent/runs",
+    "public": false,
+    "python_method": "begin_agent_run",
+    "request_schema": null
+  },
+  "postAgentRunCheckpoint": {
+    "method": "POST",
+    "node_method": "checkpointAgentRun",
+    "path": "/v1/agent/runs/checkpoints",
+    "public": false,
+    "python_method": "checkpoint_agent_run",
+    "request_schema": null
+  },
+  "postAgentRunComplete": {
+    "method": "POST",
+    "node_method": "endAgentRun",
+    "path": "/v1/agent/runs/complete",
+    "public": false,
+    "python_method": "end_agent_run",
+    "request_schema": null
+  },
+  "postAgentRunExplain": {
+    "method": "POST",
+    "node_method": "explainAgentRun",
+    "path": "/v1/agent/runs/explain",
+    "public": false,
+    "python_method": "explain_agent_run",
+    "request_schema": null
+  },
+  "postAgentRunGuardrailEvent": {
+    "method": "POST",
+    "node_method": "recordGuardrailEvent",
+    "path": "/v1/agent/runs/guardrail-events",
+    "public": false,
+    "python_method": "record_guardrail_event",
+    "request_schema": null
+  },
+  "postAgentRunHandoff": {
+    "method": "POST",
+    "node_method": "handoffAgentRun",
+    "path": "/v1/agent/runs/handoffs",
+    "public": false,
+    "python_method": "handoff_agent_run",
+    "request_schema": null
+  },
+  "postAgentRunInterrupt": {
+    "method": "POST",
+    "node_method": "interruptAgentRun",
+    "path": "/v1/agent/runs/interrupts",
+    "public": false,
+    "python_method": "interrupt_agent_run",
+    "request_schema": null
+  },
   "postAgentRunReplay": {
     "method": "POST",
     "node_method": "replayAgentRun",
@@ -154,6 +274,78 @@ export const OPENAPI_OPERATIONS = Object.freeze({
     "python_method": "replay_agent_run",
     "request_schema": "#/components/schemas/AgentRunReplayRequest"
   },
+  "postAgentRunSettle": {
+    "method": "POST",
+    "node_method": "settleAgentRun",
+    "path": "/v1/agent/runs/settle",
+    "public": false,
+    "python_method": "settle_agent_run",
+    "request_schema": null
+  },
+  "postAgentRunStep": {
+    "method": "POST",
+    "node_method": "recordAgentStep",
+    "path": "/v1/agent/runs/steps",
+    "public": false,
+    "python_method": "record_agent_step",
+    "request_schema": null
+  },
+  "postAgentRunTrace": {
+    "method": "POST",
+    "node_method": "traceAgentRun",
+    "path": "/v1/agent/runs/trace",
+    "public": false,
+    "python_method": "trace_agent_run",
+    "request_schema": null
+  },
+  "postAgentWorkflow": {
+    "method": "POST",
+    "node_method": "createAgentWorkflow",
+    "path": "/v1/agent/workflows",
+    "public": false,
+    "python_method": "create_agent_workflow",
+    "request_schema": null
+  },
+  "postExternalActionApprove": {
+    "method": "POST",
+    "node_method": "approveExternalAction",
+    "path": "/v1/agent/external-actions/{action_instance_id}/approve",
+    "public": false,
+    "python_method": "approve_external_action",
+    "request_schema": null
+  },
+  "postExternalActionClaim": {
+    "method": "POST",
+    "node_method": "claimExternalAction",
+    "path": "/v1/agent/external-actions/claim",
+    "public": false,
+    "python_method": "claim_external_action",
+    "request_schema": null
+  },
+  "postExternalActionConfirm": {
+    "method": "POST",
+    "node_method": "confirmExternalAction",
+    "path": "/v1/agent/external-actions/{action_instance_id}/confirm",
+    "public": false,
+    "python_method": "confirm_external_action",
+    "request_schema": null
+  },
+  "postExternalActionPropose": {
+    "method": "POST",
+    "node_method": "proposeExternalAction",
+    "path": "/v1/agent/external-actions/propose",
+    "public": false,
+    "python_method": "propose_external_action",
+    "request_schema": null
+  },
+  "postObservabilitySink": {
+    "method": "POST",
+    "node_method": "createObservabilitySink",
+    "path": "/v1/observability/sinks",
+    "public": false,
+    "python_method": "create_observability_sink",
+    "request_schema": null
+  },
   "postQuery": {
     "method": "POST",
     "node_method": "query",
@@ -210,6 +402,14 @@ export const OPENAPI_OPERATIONS = Object.freeze({
     "python_method": "run_hybrid_reembed_jobs",
     "request_schema": "#/components/schemas/HybridReembedRunRequest"
   },
+  "setAdminTenantBudget": {
+    "method": "POST",
+    "node_method": "setAdminTenantBudget",
+    "path": "/v1/admin/tenant-budgets",
+    "public": false,
+    "python_method": "set_admin_tenant_budget",
+    "request_schema": null
+  },
   "settleAgentProposal": {
     "method": "POST",
     "node_method": "settleWrite",
@@ -223,6 +423,7 @@ export const PYTHON_OPERATION_METHODS = Object.freeze({
   "approveAgentProposal": "approve_write",
   "cancelAgentProposal": "cancel_write",
   "cancelHybridReembedJob": "cancel_hybrid_reembed_job",
+  "clearAdminTenantBudget": "clear_admin_tenant_budget",
   "commitAgentProposal": "commit_write",
   "createAdminBackup": "create_admin_backup",
   "getAdminCheck": "admin_check",
@@ -235,10 +436,33 @@ export const PYTHON_OPERATION_METHODS = Object.freeze({
   "getOpenApi": "openapi",
   "pauseHybridReembedJob": "pause_hybrid_reembed_job",
   "postAdminShutdown": "shutdown",
+  "postAgentAdapter": "create_agent_adapter",
+  "postAgentAdapterToolCall": "call_adapter_tool",
+  "postAgentAdapterTools": "adapter_tools",
   "postAgentCapabilities": "list_capabilities",
+  "postAgentEval": "create_agent_eval",
+  "postAgentEvalDiff": "diff_agent_eval",
+  "postAgentEvalFailures": "agent_eval_failures",
+  "postAgentEvalRun": "run_agent_eval",
   "postAgentInvoke": "invoke_agent_capability",
   "postAgentMemory": "memory_command",
+  "postAgentRun": "begin_agent_run",
+  "postAgentRunCheckpoint": "checkpoint_agent_run",
+  "postAgentRunComplete": "end_agent_run",
+  "postAgentRunExplain": "explain_agent_run",
+  "postAgentRunGuardrailEvent": "record_guardrail_event",
+  "postAgentRunHandoff": "handoff_agent_run",
+  "postAgentRunInterrupt": "interrupt_agent_run",
   "postAgentRunReplay": "replay_agent_run",
+  "postAgentRunSettle": "settle_agent_run",
+  "postAgentRunStep": "record_agent_step",
+  "postAgentRunTrace": "trace_agent_run",
+  "postAgentWorkflow": "create_agent_workflow",
+  "postExternalActionApprove": "approve_external_action",
+  "postExternalActionClaim": "claim_external_action",
+  "postExternalActionConfirm": "confirm_external_action",
+  "postExternalActionPropose": "propose_external_action",
+  "postObservabilitySink": "create_observability_sink",
   "postQuery": "query",
   "postResourceRead": "read_resource",
   "postSql": "execute",
@@ -246,12 +470,14 @@ export const PYTHON_OPERATION_METHODS = Object.freeze({
   "rejectAgentProposal": "reject_write",
   "resumeHybridReembedJob": "resume_hybrid_reembed_job",
   "runHybridReembedJobs": "run_hybrid_reembed_jobs",
+  "setAdminTenantBudget": "set_admin_tenant_budget",
   "settleAgentProposal": "settle_write"
 });
 export const NODE_OPERATION_METHODS = Object.freeze({
   "approveAgentProposal": "approveWrite",
   "cancelAgentProposal": "cancelWrite",
   "cancelHybridReembedJob": "cancelHybridReembedJob",
+  "clearAdminTenantBudget": "clearAdminTenantBudget",
   "commitAgentProposal": "commitWrite",
   "createAdminBackup": "createAdminBackup",
   "getAdminCheck": "adminCheck",
@@ -264,10 +490,33 @@ export const NODE_OPERATION_METHODS = Object.freeze({
   "getOpenApi": "openapi",
   "pauseHybridReembedJob": "pauseHybridReembedJob",
   "postAdminShutdown": "shutdown",
+  "postAgentAdapter": "createAgentAdapter",
+  "postAgentAdapterToolCall": "callAdapterTool",
+  "postAgentAdapterTools": "adapterTools",
   "postAgentCapabilities": "listCapabilities",
+  "postAgentEval": "createAgentEval",
+  "postAgentEvalDiff": "diffAgentEval",
+  "postAgentEvalFailures": "agentEvalFailures",
+  "postAgentEvalRun": "runAgentEval",
   "postAgentInvoke": "invokeAgentCapability",
   "postAgentMemory": "memoryCommand",
+  "postAgentRun": "beginAgentRun",
+  "postAgentRunCheckpoint": "checkpointAgentRun",
+  "postAgentRunComplete": "endAgentRun",
+  "postAgentRunExplain": "explainAgentRun",
+  "postAgentRunGuardrailEvent": "recordGuardrailEvent",
+  "postAgentRunHandoff": "handoffAgentRun",
+  "postAgentRunInterrupt": "interruptAgentRun",
   "postAgentRunReplay": "replayAgentRun",
+  "postAgentRunSettle": "settleAgentRun",
+  "postAgentRunStep": "recordAgentStep",
+  "postAgentRunTrace": "traceAgentRun",
+  "postAgentWorkflow": "createAgentWorkflow",
+  "postExternalActionApprove": "approveExternalAction",
+  "postExternalActionClaim": "claimExternalAction",
+  "postExternalActionConfirm": "confirmExternalAction",
+  "postExternalActionPropose": "proposeExternalAction",
+  "postObservabilitySink": "createObservabilitySink",
   "postQuery": "query",
   "postResourceRead": "readResource",
   "postSql": "execute",
@@ -275,6 +524,7 @@ export const NODE_OPERATION_METHODS = Object.freeze({
   "rejectAgentProposal": "rejectWrite",
   "resumeHybridReembedJob": "resumeHybridReembedJob",
   "runHybridReembedJobs": "runHybridReembedJobs",
+  "setAdminTenantBudget": "setAdminTenantBudget",
   "settleAgentProposal": "settleWrite"
 });
 export const PUBLIC_OPERATIONS = Object.freeze([

package/package.json

@@ -1,20 +1,27 @@
 {
   "name": "@synapsor/client",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Node.js SDK for Synapsor, the agent-native database for auditable AI applications",
   "type": "module",
   "main": "./synapsor.mjs",
+  "bin": {
+    "synapsor": "bin/synapsor.mjs"
+  },
   "exports": {
-    ".": "./synapsor.mjs"
+    ".": "./synapsor.mjs",
+    "./bin/synapsor": "./bin/synapsor.mjs",
+    "./external-db-writeback": "./external-db-writeback.mjs"
   },
   "files": [
+    "bin/synapsor.mjs",
+    "external-db-writeback.mjs",
     "synapsor.mjs",
     "generated-contract.mjs",
     "README.md",
     "package.json"
   ],
   "scripts": {
-    "build": "node --check synapsor.mjs && node --check generated-contract.mjs",
+    "build": "node --check synapsor.mjs && node --check generated-contract.mjs && node --check external-db-writeback.mjs && node --check bin/synapsor.mjs",
     "test": "node --test test/*.test.mjs"
   },
   "keywords": [
@@ -28,7 +35,7 @@
   "homepage": "https://synapsor.ai",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/sandeshtiwari/Synapsor.git"
+    "url": "git+https://github.com/synapsor/synapsor.git"
   },
   "bugs": {
     "url": "https://synapsor.ai/contact"