braintrust 0.0.141-dev → 0.0.141

package/dist/browser.js

@@ -44,6 +44,7 @@ __export(browser_exports, {
   X_CACHED_HEADER: () => X_CACHED_HEADER,
   _internalGetGlobalState: () => _internalGetGlobalState,
   _internalSetInitialState: () => _internalSetInitialState,
+  braintrustStreamChunkSchema: () => braintrustStreamChunkSchema,
   createFinalValuePassThroughStream: () => createFinalValuePassThroughStream,
   currentExperiment: () => currentExperiment,
   currentLogger: () => currentLogger,
@@ -148,27 +149,79 @@ var LazyValue = class {
     return this.value.hasComputed;
   }
 };
+function _urljoin(...parts) {
+  return parts.map(
+    (x, i) => x.replace(/^\//, "").replace(i < parts.length - 1 ? /\/$/ : "", "")
+  ).filter((x) => x.trim() !== "").join("/");
+}
 
 // src/logger.ts
 var import_mustache = __toESM(require("mustache"));
-var import_zod = require("zod");
+var import_zod2 = require("zod");
 
-// src/stream.ts
+// src/functions/stream.ts
 var import_typespecs = require("@braintrust/core/typespecs");
 var import_eventsource_parser = require("eventsource-parser");
+var import_zod = require("zod");
+var braintrustStreamChunkSchema = import_zod.z.union([
+  import_zod.z.object({
+    type: import_zod.z.literal("text_delta"),
+    data: import_zod.z.string()
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("json_delta"),
+    data: import_zod.z.string()
+  })
+]);
 var BraintrustStream = class _BraintrustStream {
   stream;
+  memoizedFinalValue;
   constructor(baseStream) {
     this.stream = baseStream.pipeThrough(btStreamParser());
   }
+  /**
+   * Copy the stream. This returns a new stream that shares the same underlying
+   * stream (via `tee`). Since streams are consumed in Javascript, use `copy()` if you
+   * need to use the stream multiple times.
+   *
+   * @returns A new stream that you can independently consume.
+   */
   copy() {
     const [newStream, copyStream] = this.stream.tee();
     this.stream = copyStream;
     return new _BraintrustStream(newStream);
   }
+  /**
+   * Get the underlying ReadableStream.
+   *
+   * @returns The underlying ReadableStream<BraintrustStreamChunk>.
+   */
   toReadableStream() {
     return this.stream;
   }
+  /**
+   * Get the final value of the stream. The final value is the concatenation of all
+   * the chunks in the stream, deserialized into a string or JSON object, depending on
+   * the value's type.
+   *
+   * This function returns a promise that resolves when the stream is closed, and
+   * contains the final value. Multiple calls to `finalValue()` will return the same
+   * promise, so it is safe to call this multiple times.
+   *
+   * This function consumes the stream, so if you need to use the stream multiple
+   * times, you should call `copy()` first.
+   *
+   * @returns A promise that resolves with the final value of the stream or `undefined` if the stream is empty.
+   */
+  finalValue() {
+    if (this.memoizedFinalValue) {
+      return this.memoizedFinalValue;
+    }
+    this.memoizedFinalValue = new Promise((resolve, reject) => {
+      const stream = this.stream.pipeThrough(createFinalValuePassThroughStream(resolve)).pipeTo(devNullWritableStream());
+    });
+    return this.memoizedFinalValue;
+  }
 };
 function btStreamParser() {
   const decoder = new TextDecoder();
@@ -223,9 +276,17 @@ function createFinalValuePassThroughStream(onFinal) {
     transform(chunk, controller) {
       if (typeof chunk === "string") {
         textChunks.push(chunk);
+        controller.enqueue({
+          type: "text_delta",
+          data: chunk
+        });
       } else if (chunk instanceof Uint8Array) {
         textChunks.push(decoder.decode(chunk));
-      } else {
+        controller.enqueue({
+          type: "text_delta",
+          data: decoder.decode(chunk)
+        });
+      } else if (braintrustStreamChunkSchema.safeParse(chunk).success) {
         const chunkType = chunk.type;
         switch (chunkType) {
           case "text_delta":
@@ -239,6 +300,8 @@ function createFinalValuePassThroughStream(onFinal) {
             throw new Error(`Unknown chunk type ${_type}`);
         }
         controller.enqueue(chunk);
+      } else {
+        throw new Error(`Unknown chunk type ${chunk}`);
       }
     },
     flush(controller) {
@@ -300,14 +363,14 @@ var NoopSpan = class {
   }
 };
 var NOOP_SPAN = new NoopSpan();
-var loginSchema = import_zod.z.strictObject({
-  appUrl: import_zod.z.string(),
-  appPublicUrl: import_zod.z.string(),
-  orgName: import_zod.z.string(),
-  logUrl: import_zod.z.string(),
-  proxyUrl: import_zod.z.string(),
-  loginToken: import_zod.z.string(),
-  orgId: import_zod.z.string().nullish(),
+var loginSchema = import_zod2.z.strictObject({
+  appUrl: import_zod2.z.string(),
+  appPublicUrl: import_zod2.z.string(),
+  orgName: import_zod2.z.string(),
+  apiUrl: import_zod2.z.string(),
+  proxyUrl: import_zod2.z.string(),
+  loginToken: import_zod2.z.string(),
+  orgId: import_zod2.z.string().nullish(),
   gitMetadataSettings: import_core.gitMetadataSettingsSchema.nullish()
 });
 var BraintrustState = class _BraintrustState {
@@ -322,7 +385,7 @@ var BraintrustState = class _BraintrustState {
     }
     const defaultGetLogConn = async () => {
       await this.login({});
-      return this.logConn();
+      return this.apiConn();
     };
     this._bgLogger = new BackgroundLogger(new LazyValue(defaultGetLogConn));
     this.resetLoginInfo();
@@ -333,7 +396,7 @@ var BraintrustState = class _BraintrustState {
   // (safely) dynamically cast it whenever retrieving the logger.
   currentLogger;
   currentSpan;
-  // Any time we re-log in, we directly update the logConn inside the logger.
+  // Any time we re-log in, we directly update the apiConn inside the logger.
   // This is preferable to replacing the whole logger, which would create the
   // possibility of multiple loggers floating around, which may not log in a
   // deterministic order.
@@ -343,13 +406,13 @@ var BraintrustState = class _BraintrustState {
   loginToken = null;
   orgId = null;
   orgName = null;
-  logUrl = null;
+  apiUrl = null;
   proxyUrl = null;
   loggedIn = false;
   gitMetadataSettings;
   fetch = globalThis.fetch;
+  _appConn = null;
   _apiConn = null;
-  _logConn = null;
   _proxyConn = null;
   resetLoginInfo() {
     this.appUrl = null;
@@ -357,12 +420,12 @@ var BraintrustState = class _BraintrustState {
     this.loginToken = null;
     this.orgId = null;
     this.orgName = null;
-    this.logUrl = null;
+    this.apiUrl = null;
     this.proxyUrl = null;
     this.loggedIn = false;
     this.gitMetadataSettings = void 0;
+    this._appConn = null;
     this._apiConn = null;
-    this._logConn = null;
     this._proxyConn = null;
   }
   copyLoginInfo(other) {
@@ -371,12 +434,12 @@ var BraintrustState = class _BraintrustState {
     this.loginToken = other.loginToken;
     this.orgId = other.orgId;
     this.orgName = other.orgName;
-    this.logUrl = other.logUrl;
+    this.apiUrl = other.apiUrl;
     this.proxyUrl = other.proxyUrl;
     this.loggedIn = other.loggedIn;
     this.gitMetadataSettings = other.gitMetadataSettings;
+    this._appConn = other._appConn;
     this._apiConn = other._apiConn;
-    this._logConn = other._logConn;
     this._proxyConn = other._proxyConn;
   }
   serialize() {
@@ -385,7 +448,7 @@ var BraintrustState = class _BraintrustState {
         "Cannot serialize BraintrustState without being logged in"
       );
     }
-    if (!this.appUrl || !this.appPublicUrl || !this.logUrl || !this.proxyUrl || !this.orgName || !this.loginToken || !this.loggedIn) {
+    if (!this.appUrl || !this.appPublicUrl || !this.apiUrl || !this.proxyUrl || !this.orgName || !this.loginToken || !this.loggedIn) {
       throw new Error(
         "Cannot serialize BraintrustState without all login attributes"
       );
@@ -396,7 +459,7 @@ var BraintrustState = class _BraintrustState {
       loginToken: this.loginToken,
       orgId: this.orgId,
       orgName: this.orgName,
-      logUrl: this.logUrl,
+      apiUrl: this.apiUrl,
       proxyUrl: this.proxyUrl,
       gitMetadataSettings: this.gitMetadataSettings
     };
@@ -417,22 +480,23 @@ var BraintrustState = class _BraintrustState {
         "Cannot deserialize BraintrustState without a login token"
       );
     }
-    state.logConn().set_token(state.loginToken);
-    state.logConn().make_long_lived();
     state.apiConn().set_token(state.loginToken);
+    state.apiConn().make_long_lived();
+    state.appConn().set_token(state.loginToken);
+    state.proxyConn().make_long_lived();
     state.proxyConn().set_token(state.loginToken);
     state.loggedIn = true;
-    state.loginReplaceLogConn(state.logConn());
+    state.loginReplaceApiConn(state.apiConn());
     return state;
   }
   setFetch(fetch) {
     this.loginParams.fetch = fetch;
     this.fetch = fetch;
-    this._logConn?.setFetch(fetch);
     this._apiConn?.setFetch(fetch);
+    this._appConn?.setFetch(fetch);
   }
   async login(loginParams) {
-    if (this.logUrl && !loginParams.forceLogin) {
+    if (this.apiUrl && !loginParams.forceLogin) {
       return;
     }
     const newState = await loginToState({
@@ -441,23 +505,23 @@ var BraintrustState = class _BraintrustState {
     });
     this.copyLoginInfo(newState);
   }
-  apiConn() {
-    if (!this._apiConn) {
+  appConn() {
+    if (!this._appConn) {
       if (!this.appUrl) {
-        throw new Error("Must initialize appUrl before requesting apiConn");
+        throw new Error("Must initialize appUrl before requesting appConn");
       }
-      this._apiConn = new HTTPConnection(this.appUrl, this.fetch);
+      this._appConn = new HTTPConnection(this.appUrl, this.fetch);
     }
-    return this._apiConn;
+    return this._appConn;
   }
-  logConn() {
-    if (!this._logConn) {
-      if (!this.logUrl) {
-        throw new Error("Must initialize logUrl before requesting logConn");
+  apiConn() {
+    if (!this._apiConn) {
+      if (!this.apiUrl) {
+        throw new Error("Must initialize apiUrl before requesting apiConn");
       }
-      this._logConn = new HTTPConnection(this.logUrl, this.fetch);
+      this._apiConn = new HTTPConnection(this.apiUrl, this.fetch);
     }
-    return this._logConn;
+    return this._apiConn;
   }
   proxyConn() {
     if (!this._proxyConn) {
@@ -472,8 +536,8 @@ var BraintrustState = class _BraintrustState {
     return this._bgLogger;
   }
   // Should only be called by the login function.
-  loginReplaceLogConn(logConn) {
-    this._bgLogger.internalReplaceLogConn(logConn);
+  loginReplaceApiConn(apiConn) {
+    this._bgLogger.internalReplaceApiConn(apiConn);
   }
 };
 var _globalState;
@@ -780,11 +844,6 @@ var Logger = class {
   parentObjectType() {
     return import_core.SpanObjectTypeV2.PROJECT_LOGS;
   }
-  triggerWaitUntilFlush() {
-    if (!this.state.bgLogger().syncFlush) {
-      return (0, import_functions.waitUntil)(this.state.bgLogger().flush());
-    }
-  }
   /**
    * Log a single event. The event will be batched and uploaded behind the scenes if `logOptions.asyncFlush` is true.
    *
@@ -810,7 +869,6 @@ var Logger = class {
     this.lastStartTime = span.end();
     const ret = span.id;
     if (this.asyncFlush === true) {
-      this.triggerWaitUntilFlush();
       return ret;
     } else {
       return (async () => {
@@ -838,7 +896,6 @@ var Logger = class {
       () => span.end()
     );
     if (this.asyncFlush) {
-      this.triggerWaitUntilFlush();
       return ret;
     } else {
       return (async () => {
@@ -918,7 +975,7 @@ var Logger = class {
 function castLogger(logger, asyncFlush) {
   if (logger === void 0)
     return void 0;
-  if (asyncFlush && !!asyncFlush !== !!logger.asyncFlush) {
+  if (asyncFlush !== void 0 && !!asyncFlush !== !!logger.asyncFlush) {
     throw new Error(
       `Asserted asyncFlush setting ${asyncFlush} does not match stored logger's setting ${logger.asyncFlush}`
     );
@@ -932,7 +989,7 @@ function now() {
   return (/* @__PURE__ */ new Date()).getTime();
 }
 var BackgroundLogger = class _BackgroundLogger {
-  logConn;
+  apiConn;
   items = [];
   activeFlush = Promise.resolve();
   activeFlushResolved = true;
@@ -950,8 +1007,8 @@ var BackgroundLogger = class _BackgroundLogger {
     numDropped: 0,
     lastLoggedTimestamp: 0
   };
-  constructor(logConn) {
-    this.logConn = logConn;
+  constructor(apiConn) {
+    this.apiConn = apiConn;
     const syncFlushEnv = Number(isomorph_default.getEnv("BRAINTRUST_SYNC_FLUSH"));
     if (!isNaN(syncFlushEnv)) {
       this.syncFlush = Boolean(syncFlushEnv);
@@ -1097,7 +1154,7 @@ var BackgroundLogger = class _BackgroundLogger {
     return [];
   }
   async submitLogsRequest(items) {
-    const conn = await this.logConn.get();
+    const conn = await this.apiConn.get();
     const dataStr = constructLogs3Data(items);
     if (this.allPublishPayloadsDir) {
       await _BackgroundLogger.writePayloadToDir({
@@ -1235,14 +1292,15 @@ Error: ${errorText}`;
           this.activeFlushResolved = true;
         }
       })();
+      (0, import_functions.waitUntil)(this.activeFlush);
     }
   }
   logFailedPayloadsDir() {
     console.warn(`Logging failed payloads to ${this.failedPublishPayloadsDir}`);
   }
   // Should only be called by BraintrustState.
-  internalReplaceLogConn(logConn) {
-    this.logConn = new LazyValue(async () => logConn);
+  internalReplaceApiConn(apiConn) {
+    this.apiConn = new LazyValue(async () => apiConn);
   }
 };
 function init(projectOrOptions, optionalOptions) {
@@ -1296,7 +1354,7 @@ function init(projectOrOptions, optionalOptions) {
           org_name: state.orgName,
           experiment_name: experiment
         };
-        const response = await state.apiConn().post_json("api/experiment/get", args);
+        const response = await state.appConn().post_json("api/experiment/get", args);
         if (response.length === 0) {
           throw new Error(
             `Experiment ${experiment} not found in project ${projectId ?? project}.`
@@ -1377,7 +1435,7 @@ function init(projectOrOptions, optionalOptions) {
       let response = null;
       while (true) {
         try {
-          response = await state.apiConn().post_json("api/experiment/register", args);
+          response = await state.appConn().post_json("api/experiment/register", args);
           break;
         } catch (e) {
           if (args["base_experiment"] && `${"data" in e && e.data}`.includes("base experiment")) {
@@ -1483,7 +1541,7 @@ function initDataset(projectOrOptions, optionalOptions) {
         dataset_name: dataset,
         description
       };
-      const response = await state.apiConn().post_json("api/dataset/register", args);
+      const response = await state.appConn().post_json("api/dataset/register", args);
       return {
         project: {
           id: response.project.id,
@@ -1513,7 +1571,7 @@ async function computeLoggerMetadata(state, {
 }) {
   const org_id = state.orgId;
   if (isEmpty(project_id)) {
-    const response = await state.apiConn().post_json("api/project/register", {
+    const response = await state.appConn().post_json("api/project/register", {
       project_name: project_name || GLOBAL_PROJECT,
       org_id
     });
@@ -1526,7 +1584,7 @@ async function computeLoggerMetadata(state, {
       }
     };
   } else if (isEmpty(project_name)) {
-    const response = await state.apiConn().get_json("api/project", {
+    const response = await state.appConn().get_json("api/project", {
       id: project_id
     });
     return {
@@ -1616,7 +1674,7 @@ async function loadPrompt({
     slug,
     version
   };
-  const response = await state.logConn().get_json("v1/prompt", args);
+  const response = await state.apiConn().get_json("v1/prompt", args);
   if (!("objects" in response) || response.objects.length === 0) {
     throw new Error(
       `Prompt ${slug} not found in ${[projectName ?? projectId]}`
@@ -1678,7 +1736,7 @@ async function loginToState(options = {}) {
     );
     const info = await resp.json();
     _check_org_info(state, info.org_info, orgName);
-    conn = state.logConn();
+    conn = state.apiConn();
     conn.set_token(apiKey);
   } else {
     throw new Error(
@@ -1689,11 +1747,11 @@ async function loginToState(options = {}) {
     throw new Error("Conn should be set at this point (a bug)");
   }
   conn.make_long_lived();
-  state.apiConn().set_token(apiKey);
+  state.appConn().set_token(apiKey);
   state.proxyConn().set_token(apiKey);
   state.loginToken = conn.token;
   state.loggedIn = true;
-  state.loginReplaceLogConn(conn);
+  state.loginReplaceApiConn(conn);
   return state;
 }
 function log(event) {
@@ -1745,7 +1803,7 @@ function getSpanParentObject(options) {
   return NOOP_SPAN;
 }
 function traced(callback, args) {
-  const { span, isLogger } = startSpanAndIsLogger(args);
+  const { span, isSyncFlushLogger } = startSpanAndIsLogger(args);
   const ret = runFinally(
     () => {
       if (args?.setCurrent ?? true) {
@@ -1761,7 +1819,7 @@ function traced(callback, args) {
   } else {
     return (async () => {
       const awaitedRet = await ret;
-      if (isLogger) {
+      if (isSyncFlushLogger) {
         await span.flush();
       }
       return awaitedRet;
@@ -1840,14 +1898,19 @@ function startSpanAndIsLogger(args) {
     });
     return {
       span,
-      isLogger: components.objectType === import_core.SpanObjectTypeV2.PROJECT_LOGS
+      isSyncFlushLogger: components.objectType === import_core.SpanObjectTypeV2.PROJECT_LOGS && // Since there's no parent logger here, we're free to choose the async flush
+      // behavior, and therefore propagate along whatever we get from the arguments
+      !args?.asyncFlush
     };
   } else {
     const parentObject = getSpanParentObject({
       asyncFlush: args?.asyncFlush
     });
     const span = parentObject.startSpan(args);
-    return { span, isLogger: parentObject.kind === "logger" };
+    return {
+      span,
+      isSyncFlushLogger: parentObject.kind === "logger" && !parentObject.asyncFlush
+    };
   }
 }
 function withCurrent(span, callback, state = _globalState) {
@@ -1861,13 +1924,8 @@ function _check_org_info(state, org_info, org_name) {
     if (org_name === void 0 || org.name === org_name) {
       state.orgId = org.id;
       state.orgName = org.name;
-      state.logUrl = isomorph_default.getEnv("BRAINTRUST_API_URL") ?? org.api_url;
+      state.apiUrl = isomorph_default.getEnv("BRAINTRUST_API_URL") ?? org.api_url;
       state.proxyUrl = isomorph_default.getEnv("BRAINTRUST_PROXY_URL") ?? org.proxy_url;
-      if (state.proxyUrl) {
-        const url = new URL(state.proxyUrl);
-        url.pathname = "";
-        state.proxyUrl = url.toString();
-      }
       state.gitMetadataSettings = org.git_metadata || void 0;
       break;
     }
@@ -1878,11 +1936,6 @@ function _check_org_info(state, org_info, org_name) {
     );
   }
 }
-function _urljoin(...parts) {
-  return parts.map(
-    (x, i) => x.replace(/^\//, "").replace(i < parts.length - 1 ? /\/$/ : "", "")
-  ).join("/");
-}
 function validateTags(tags) {
   const seen = /* @__PURE__ */ new Set();
   for (const tag of tags) {
@@ -1996,7 +2049,7 @@ var ObjectFetcher = class {
   async fetchedData() {
     if (this._fetchedData === void 0) {
       const state = await this.getState();
-      const resp = await state.logConn().get(
+      const resp = await state.apiConn().get(
         `v1/${this.objectType}/${await this.id}/fetch`,
         {
           version: this.pinnedVersion
@@ -2142,7 +2195,7 @@ var Experiment = class extends ObjectFetcher {
   }
   async fetchBaseExperiment() {
     const state = await this.getState();
-    const conn = state.apiConn();
+    const conn = state.appConn();
     try {
       const resp = await conn.post("/api/base_experiment/get_id", {
         id: await this.id
@@ -2189,7 +2242,7 @@ var Experiment = class extends ObjectFetcher {
           comparisonExperimentName = baseExperiment.name;
         }
       }
-      const results = await state.logConn().get_json(
+      const results = await state.apiConn().get_json(
         "/experiment-comparison2",
         {
           experiment_id: await this.id,
@@ -2377,29 +2430,10 @@ var SpanImpl = class _SpanImpl {
     event,
     internalData
   }) {
-    const sanitized = validateAndSanitizeExperimentLogPartialArgs(event ?? {});
-    let sanitizedAndInternalData = { ...internalData };
-    (0, import_core.mergeDicts)(sanitizedAndInternalData, sanitized);
-    const serializableInternalData = {};
-    const lazyInternalData = {};
-    for (const [key, value] of Object.entries(sanitizedAndInternalData)) {
-      if (value instanceof BraintrustStream) {
-        const streamCopy = value.copy();
-        lazyInternalData[key] = new LazyValue(async () => {
-          return await new Promise((resolve) => {
-            streamCopy.toReadableStream().pipeThrough(createFinalValuePassThroughStream(resolve)).pipeTo(devNullWritableStream());
-          });
-        });
-      } else if (value instanceof ReadableStream) {
-        lazyInternalData[key] = new LazyValue(async () => {
-          return await new Promise((resolve) => {
-            value.pipeThrough(createFinalValuePassThroughStream(resolve)).pipeTo(devNullWritableStream());
-          });
-        });
-      } else {
-        serializableInternalData[key] = value;
-      }
-    }
+    const [serializableInternalData, lazyInternalData] = splitLoggingData({
+      event,
+      internalData
+    });
     let partialRecord = {
       id: this.id,
       span_id: this.spanId,
@@ -2517,6 +2551,36 @@ var SpanImpl = class _SpanImpl {
     return this.end(args);
   }
 };
+function splitLoggingData({
+  event,
+  internalData
+}) {
+  const sanitized = validateAndSanitizeExperimentLogPartialArgs(event ?? {});
+  const sanitizedAndInternalData = {};
+  (0, import_core.mergeDicts)(sanitizedAndInternalData, internalData || {});
+  (0, import_core.mergeDicts)(sanitizedAndInternalData, sanitized);
+  const serializableInternalData = {};
+  const lazyInternalData = {};
+  for (const [key, value] of Object.entries(sanitizedAndInternalData)) {
+    if (value instanceof BraintrustStream) {
+      const streamCopy = value.copy();
+      lazyInternalData[key] = new LazyValue(async () => {
+        return await new Promise((resolve) => {
+          streamCopy.toReadableStream().pipeThrough(createFinalValuePassThroughStream(resolve)).pipeTo(devNullWritableStream());
+        });
+      });
+    } else if (value instanceof ReadableStream) {
+      lazyInternalData[key] = new LazyValue(async () => {
+        return await new Promise((resolve) => {
+          value.pipeThrough(createFinalValuePassThroughStream(resolve)).pipeTo(devNullWritableStream());
+        });
+      });
+    } else {
+      serializableInternalData[key] = value;
+    }
+  }
+  return [serializableInternalData, lazyInternalData];
+}
 var Dataset = class extends ObjectFetcher {
   constructor(state, lazyMetadata, pinnedVersion, legacy) {
     const isLegacyDataset = legacy ?? import_core.DEFAULT_IS_LEGACY_DATASET;
@@ -2633,7 +2697,7 @@ var Dataset = class extends ObjectFetcher {
     )}`;
     let dataSummary = void 0;
     if (summarizeData) {
-      dataSummary = await state.logConn().get_json(
+      dataSummary = await state.apiConn().get_json(
         "dataset-summary",
         {
           dataset_id: await this.id
@@ -2739,7 +2803,7 @@ var Prompt = class {
     if (!prompt) {
       throw new Error("Empty prompt");
     }
-    const dictArgParsed = import_zod.z.record(import_zod.z.unknown()).safeParse(buildArgs);
+    const dictArgParsed = import_zod2.z.record(import_zod2.z.unknown()).safeParse(buildArgs);
     const variables = {
       input: buildArgs,
       ...dictArgParsed.success ? dictArgParsed.data : {}
@@ -2815,12 +2879,12 @@ async function invoke(args) {
     appUrl,
     forceLogin,
     fetch,
-    arg,
+    input,
     parent: parentArg,
     state: stateArg,
     stream,
     schema,
-    ...functionId
+    ...functionIdArgs
   } = args;
   const state = stateArg ?? _internalGetGlobalState();
   await state.login({
@@ -2829,10 +2893,16 @@ async function invoke(args) {
     appUrl,
     forceLogin
   });
-  const parent = parentArg ? typeof parentArg === "string" ? parentArg : await parentArg.export() : await currentSpan().export();
+  const parent = parentArg ? typeof parentArg === "string" ? parentArg : await parentArg.export() : await getSpanParentObject().export();
+  const functionId = import_typespecs3.functionIdSchema.safeParse(functionIdArgs);
+  if (!functionId.success) {
+    throw new Error(
+      `Invalid function ID arguments: ${functionId.error.message}`
+    );
+  }
   const request = {
-    ...functionId,
-    arg,
+    ...functionId.data,
+    input,
     parent,
     stream,
     api_version: import_typespecs3.INVOKE_API_VERSION
@@ -3223,6 +3293,7 @@ configureBrowser();
   X_CACHED_HEADER,
   _internalGetGlobalState,
   _internalSetInitialState,
+  braintrustStreamChunkSchema,
   createFinalValuePassThroughStream,
   currentExperiment,
   currentLogger,