@maximem/synap-js-sdk 0.5.9 → 0.5.10

package/dist/index.d.cts

@@ -326,6 +326,15 @@ declare class HttpTransport {
      * deployment older than the field, and must mean "enforce nothing".
      */
     userContextIsolation: string | undefined;
+    /**
+     * Set by the client to its identity resolution (`initialize()`'s whoami).
+     * Python refuses every call before `initialize()`; here the first request
+     * runs it instead, so a caller who skips it gets the same identity-dependent
+     * behaviour (client-scope cache hits, the B2C check) rather than an error.
+     */
+    identityResolver: (() => Promise<void>) | undefined;
+    /** Resolve identity once, before the first request. Never throws. */
+    ready(): Promise<void>;
     /** Refuse a customer_id on a B2C instance, at the call site. */
     checkCustomerId(customerId: unknown, where: string): void;
     setTimeouts(timeouts: Partial<TimeoutConfig>): void;
@@ -1759,12 +1768,16 @@ declare class SynapClient {
     /**
      * Resolve `client_id` and `instance_id` from the API key.
      *
-     * Mirrors Python's `initialize()`. Calling it is optional here (unlike
-     * Python, which raises "SDK not initialized" from `_ensure_initialized`)
-     * because every HTTP route authenticates on the API key alone. It matters
-     * for the anticipation cache: a bundle shared at client scope is filtered on
-     * `client_id`, and an empty one fails that filter for every bundle. That was
-     * a silent cache-scope bug in Python before whoami bootstrapping existed.
+     * Mirrors Python's `initialize()`. Python raises "SDK not initialized" on
+     * any call made before it; here the first request runs the same resolution
+     * instead (`identityResolver` on the transport), so skipping this call costs
+     * nothing and breaks no existing caller. It matters for the anticipation
+     * cache: a bundle shared at client scope is filtered on `client_id`, and an
+     * empty one fails that filter for every bundle.
+     *
+     * Calling it explicitly still locks `configure()`, as in Python. Resolving
+     * on first use does not, because a caller who never called it could always
+     * configure after a request, and that keeps working.
      *
      * Best-effort and idempotent. A whoami failure leaves whatever the
      * constructor resolved and is not fatal.
@@ -1856,7 +1869,7 @@ declare class SynapClient {
  * build when the two disagree, which is the only thing that makes a manual
  * publish safe.
  */
-declare const SDK_VERSION = "0.5.9";
+declare const SDK_VERSION = "0.5.10";
 
 /**
  * `response_shape: "ranked"`: one list in the order the server ranked it.

package/dist/index.d.ts

@@ -326,6 +326,15 @@ declare class HttpTransport {
      * deployment older than the field, and must mean "enforce nothing".
      */
     userContextIsolation: string | undefined;
+    /**
+     * Set by the client to its identity resolution (`initialize()`'s whoami).
+     * Python refuses every call before `initialize()`; here the first request
+     * runs it instead, so a caller who skips it gets the same identity-dependent
+     * behaviour (client-scope cache hits, the B2C check) rather than an error.
+     */
+    identityResolver: (() => Promise<void>) | undefined;
+    /** Resolve identity once, before the first request. Never throws. */
+    ready(): Promise<void>;
     /** Refuse a customer_id on a B2C instance, at the call site. */
     checkCustomerId(customerId: unknown, where: string): void;
     setTimeouts(timeouts: Partial<TimeoutConfig>): void;
@@ -1759,12 +1768,16 @@ declare class SynapClient {
     /**
      * Resolve `client_id` and `instance_id` from the API key.
      *
-     * Mirrors Python's `initialize()`. Calling it is optional here (unlike
-     * Python, which raises "SDK not initialized" from `_ensure_initialized`)
-     * because every HTTP route authenticates on the API key alone. It matters
-     * for the anticipation cache: a bundle shared at client scope is filtered on
-     * `client_id`, and an empty one fails that filter for every bundle. That was
-     * a silent cache-scope bug in Python before whoami bootstrapping existed.
+     * Mirrors Python's `initialize()`. Python raises "SDK not initialized" on
+     * any call made before it; here the first request runs the same resolution
+     * instead (`identityResolver` on the transport), so skipping this call costs
+     * nothing and breaks no existing caller. It matters for the anticipation
+     * cache: a bundle shared at client scope is filtered on `client_id`, and an
+     * empty one fails that filter for every bundle.
+     *
+     * Calling it explicitly still locks `configure()`, as in Python. Resolving
+     * on first use does not, because a caller who never called it could always
+     * configure after a request, and that keeps working.
      *
      * Best-effort and idempotent. A whoami failure leaves whatever the
      * constructor resolved and is not fatal.
@@ -1856,7 +1869,7 @@ declare class SynapClient {
  * build when the two disagree, which is the only thing that makes a manual
  * publish safe.
  */
-declare const SDK_VERSION = "0.5.9";
+declare const SDK_VERSION = "0.5.10";
 
 /**
  * `response_shape: "ranked"`: one list in the order the server ranked it.

package/dist/index.js

@@ -267,6 +267,17 @@ var HttpTransport = class {
    * deployment older than the field, and must mean "enforce nothing".
    */
   userContextIsolation = void 0;
+  /**
+   * Set by the client to its identity resolution (`initialize()`'s whoami).
+   * Python refuses every call before `initialize()`; here the first request
+   * runs it instead, so a caller who skips it gets the same identity-dependent
+   * behaviour (client-scope cache hits, the B2C check) rather than an error.
+   */
+  identityResolver = void 0;
+  /** Resolve identity once, before the first request. Never throws. */
+  async ready() {
+    if (this.identityResolver !== void 0) await this.identityResolver();
+  }
   /** Refuse a customer_id on a B2C instance, at the call site. */
   checkCustomerId(customerId, where) {
     checkCustomerId(
@@ -298,6 +309,7 @@ var HttpTransport = class {
     const spec = ENDPOINTS[name];
     const correlationId = options.correlationId ?? newCorrelationId();
     const idempotent = options.idempotent ?? spec.idempotent;
+    if (name !== "whoami") await this.ready();
     let attempt = 0;
     let last = null;
     while (attempt < this.retryPolicy.maxAttempts) {
@@ -619,11 +631,10 @@ function buildFetchRequest(scope, options) {
   const conversationId = opt(options, "conversation_id", "conversationId");
   const searchQuery = opt(options, "search_query", "searchQuery");
   const maxResults = opt(options, "max_results", "maxResults") ?? 10;
-  const precisionLevel = opt(options, "precision_level", "precisionLevel") ?? "high";
   const queryDate = opt(options, "query_date", "queryDate");
   const perQuery = opt(options, "max_results_per_query", "maxResultsPerQuery");
   const responseShape = responseShapeOf(options);
-  const mode = options.mode ?? "fast";
+  const { mode, precisionLevel } = retrievalOptionsOf(options);
   if (searchQuery !== void 0 && !Array.isArray(searchQuery)) {
     throw new InvalidInputError("search_query must be an array when provided");
   }
@@ -644,13 +655,15 @@ function buildFetchRequest(scope, options) {
   if (options.include_conversation_context === false) {
     body["include_conversation_context"] = false;
   }
+  const scopePath = opt(options, "scope_path", "scopePath");
+  if (scopePath !== void 0 && scopePath !== null && Object.keys(scopePath).length > 0) {
+    body["scope"] = scopePath;
+  }
   switch (scope) {
     case "user":
       {
         if (!userId) throw new InvalidInputError("user_id is required");
         body["user_id"] = userId;
-        const scopePath = opt(options, "scope_path", "scopePath");
-        if (scopePath !== void 0) body["scope"] = scopePath;
         const contextMode = opt(options, "context_mode", "contextMode") ?? "in-conversation";
         if (!VALID_CONTEXT_MODES.includes(contextMode)) {
           throw new InvalidInputError(
@@ -697,13 +710,32 @@ function responseShapeOf(options) {
   }
   return shape;
 }
+var VALID_MODES = ["fast", "accurate"];
+var VALID_PRECISION = ["high", "medium"];
+function retrievalOptionsOf(options) {
+  const mode = options.mode ?? "fast";
+  if (!VALID_MODES.includes(mode)) {
+    throw new InvalidInputError(
+      `Invalid mode '${mode}'. Must be one of: ${VALID_MODES.join(", ")}`
+    );
+  }
+  const precisionLevel = opt(options, "precision_level", "precisionLevel") ?? "high";
+  if (!VALID_PRECISION.includes(precisionLevel)) {
+    throw new InvalidInputError(
+      `Invalid precision_level '${precisionLevel}'. Must be one of: ${VALID_PRECISION.join(", ")}`
+    );
+  }
+  return { mode, precisionLevel };
+}
 async function fetchContext(transport, scope, options = {}, hooks = {}) {
   const startedAt = Date.now();
+  await transport.ready?.();
   transport.checkCustomerId(
     opt(options, "customer_id", "customerId"),
     `${scope}.context.fetch`
   );
   const responseShape = responseShapeOf(options);
+  retrievalOptionsOf(options);
   const network = async () => {
     const { endpoint, body } = buildFetchRequest(scope, options);
     const result = await transport.request(endpoint, { body });
@@ -1922,7 +1954,7 @@ function createInstanceNamespace(credentials, cache, onTurn, agentModel = () =>
 }
 
 // src/version.ts
-var SDK_VERSION = "0.5.9";
+var SDK_VERSION = "0.5.10";
 
 // src/registry.ts
 var instances = /* @__PURE__ */ new Map();
@@ -3648,6 +3680,7 @@ var SynapClient = class _SynapClient {
   instance;
   #closed = false;
   #initialized = false;
+  #identity;
   #registryKeys;
   #compactionSubscribers;
   #shortTerm;
@@ -3698,6 +3731,7 @@ var SynapClient = class _SynapClient {
       userAgent: `@maximem/synap-js-sdk/${SDK_VERSION}`
     });
     if (options.heartbeat) this.#transport.startHeartbeat();
+    this.#transport.identityResolver = () => this.#resolveIdentity();
     this.#anticipationCache = new AnticipationCache();
     this.#fetchHooks = {
       beforeFetch: async (scope, options2) => {
@@ -3903,19 +3937,30 @@ var SynapClient = class _SynapClient {
   /**
    * Resolve `client_id` and `instance_id` from the API key.
    *
-   * Mirrors Python's `initialize()`. Calling it is optional here (unlike
-   * Python, which raises "SDK not initialized" from `_ensure_initialized`)
-   * because every HTTP route authenticates on the API key alone. It matters
-   * for the anticipation cache: a bundle shared at client scope is filtered on
-   * `client_id`, and an empty one fails that filter for every bundle. That was
-   * a silent cache-scope bug in Python before whoami bootstrapping existed.
+   * Mirrors Python's `initialize()`. Python raises "SDK not initialized" on
+   * any call made before it; here the first request runs the same resolution
+   * instead (`identityResolver` on the transport), so skipping this call costs
+   * nothing and breaks no existing caller. It matters for the anticipation
+   * cache: a bundle shared at client scope is filtered on `client_id`, and an
+   * empty one fails that filter for every bundle.
+   *
+   * Calling it explicitly still locks `configure()`, as in Python. Resolving
+   * on first use does not, because a caller who never called it could always
+   * configure after a request, and that keeps working.
    *
    * Best-effort and idempotent. A whoami failure leaves whatever the
    * constructor resolved and is not fatal.
    */
   async initialize() {
-    if (this.#initialized) return;
     this.#initialized = true;
+    await this.#resolveIdentity();
+  }
+  /** Runs whoami at most once, however many calls arrive together. */
+  #resolveIdentity() {
+    this.#identity ??= this.#whoami();
+    return this.#identity;
+  }
+  async #whoami() {
     const credentials = this.#transport.currentCredentials();
     if (credentials.clientId !== "" && credentials.instanceId !== "") return;
     try {