@pensar/apex 2.4.0 → 2.5.0-canary.2512a649

package/build/{cli-tkc598ey.js → cli-0drqd790.js}

@@ -4,7 +4,7 @@ import {
   init_auth,
   init_constants,
   signGatewayRequest
-} from "./cli-0n4r54hq.js";
+} from "./cli-ewxfjn4c.js";
 import {
   AISDKError,
   APICallError,
@@ -71,7 +71,6 @@ import {
   postFormDataToApi,
   postJsonToApi,
   readResponseWithSizeLimit,
-  require_src,
   resolve,
   safeParseAsync,
   safeParseJSON,
@@ -83,15 +82,18 @@ import {
   withoutTrailingSlash,
   zodSchema,
   zod_default
-} from "./cli-swpbx60z.js";
+} from "./cli-avmhkjtv.js";
 import {
   config,
   init_config
-} from "./cli-72cvcqhg.js";
+} from "./cli-8k8wam9m.js";
 import {
   getCurrentVersion,
   init_installation
-} from "./cli-vnynf0js.js";
+} from "./cli-h1xcrswb.js";
+import {
+  require_src
+} from "./cli-knd276ed.js";
 import {
   __callDispose,
   __commonJS,
@@ -6505,7 +6507,59 @@ var import_api, import_api2, __defProp, __export = (target, all) => {
       ...init
     });
   }
-}, toolMetadataSchema2, uiMessagesSchema, originalGenerateId3, originalGenerateId4, defaultDownload, name21 = "AI_NoSuchProviderError", marker21, symbol21, _a21, defaultDownload2;
+}, toolMetadataSchema2, uiMessagesSchema, originalGenerateId3, originalGenerateId4, defaultDownload, wrapLanguageModel = ({
+  model,
+  middleware: middlewareArg,
+  modelId,
+  providerId
+}) => {
+  return [...asArray(middlewareArg)].reverse().reduce((wrappedModel, middleware) => {
+    return doWrap({ model: wrappedModel, middleware, modelId, providerId });
+  }, model);
+}, doWrap = ({
+  model,
+  middleware: {
+    transformParams,
+    wrapGenerate,
+    wrapStream,
+    overrideProvider,
+    overrideModelId,
+    overrideSupportedUrls
+  },
+  modelId,
+  providerId
+}) => {
+  var _a22, _b, _c;
+  async function doTransform({
+    params,
+    type
+  }) {
+    return transformParams ? await transformParams({ params, type, model }) : params;
+  }
+  return {
+    specificationVersion: "v3",
+    provider: (_a22 = providerId != null ? providerId : overrideProvider == null ? undefined : overrideProvider({ model })) != null ? _a22 : model.provider,
+    modelId: (_b = modelId != null ? modelId : overrideModelId == null ? undefined : overrideModelId({ model })) != null ? _b : model.modelId,
+    supportedUrls: (_c = overrideSupportedUrls == null ? undefined : overrideSupportedUrls({ model })) != null ? _c : model.supportedUrls,
+    async doGenerate(params) {
+      const transformedParams = await doTransform({ params, type: "generate" });
+      const doGenerate = async () => model.doGenerate(transformedParams);
+      const doStream = async () => model.doStream(transformedParams);
+      return wrapGenerate ? wrapGenerate({
+        doGenerate,
+        doStream,
+        params: transformedParams,
+        model
+      }) : doGenerate();
+    },
+    async doStream(params) {
+      const transformedParams = await doTransform({ params, type: "stream" });
+      const doGenerate = async () => model.doGenerate(transformedParams);
+      const doStream = async () => model.doStream(transformedParams);
+      return wrapStream ? wrapStream({ doGenerate, doStream, params: transformedParams, model }) : doStream();
+    }
+  };
+}, name21 = "AI_NoSuchProviderError", marker21, symbol21, _a21, defaultDownload2;
 var init_dist4 = __esm(() => {
   init_dist2();
   init_dist2();
@@ -7678,6 +7732,59 @@ var init_dist4 = __esm(() => {
   defaultDownload2 = createDownload();
 });
 
+// src/core/id/id.ts
+import { randomBytes } from "node:crypto";
+function schema(prefix) {
+  return zod_default.string().startsWith(prefixes[prefix]);
+}
+function descending(prefix, given) {
+  return generateID(prefix, true, given);
+}
+function generateID(prefix, descending2, given) {
+  if (!given) {
+    return create(prefix, descending2);
+  }
+  if (!given.startsWith(prefixes[prefix])) {
+    throw new Error(`ID ${given} does not start with ${prefixes[prefix]}`);
+  }
+  return given;
+}
+function randomBase62(length) {
+  const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  let result = "";
+  const bytes = randomBytes(length);
+  for (let i = 0;i < length; i++) {
+    result += chars[bytes[i] % 62];
+  }
+  return result;
+}
+function create(prefix, descending2, timestamp) {
+  const currentTimestamp = timestamp ?? Date.now();
+  if (currentTimestamp !== lastTimestamp) {
+    lastTimestamp = currentTimestamp;
+    counter = 0;
+  }
+  counter++;
+  let now2 = BigInt(currentTimestamp) * BigInt(4096) + BigInt(counter);
+  now2 = descending2 ? ~now2 : now2;
+  const timeBytes = Buffer.alloc(6);
+  for (let i = 0;i < 6; i++) {
+    timeBytes[i] = Number(now2 >> BigInt(40 - 8 * i) & BigInt(255));
+  }
+  return prefixes[prefix] + "_" + timeBytes.toString("hex") + randomBase62(LENGTH - 12);
+}
+var prefixes, LENGTH = 26, lastTimestamp = 0, counter = 0, newSessionId = () => descending("session"), newMessageId = () => descending("message"), newPartId = () => descending("part"), isSessionId = (s) => s.startsWith(`${prefixes.session}_`);
+var init_id = __esm(() => {
+  init_zod();
+  prefixes = {
+    session: "ses",
+    message: "msg",
+    permission: "per",
+    user: "usr",
+    part: "prt"
+  };
+});
+
 // src/core/ai/models/anthropic.ts
 var ANTHROPIC_MODELS;
 var init_anthropic = __esm(() => {
@@ -15678,10 +15785,10 @@ function convertOpenAIResponsesUsage(usage) {
 function serializeToolCallArguments2(input) {
   return JSON.stringify(input === undefined ? {} : input);
 }
-function isFileId(data, prefixes) {
-  if (!prefixes)
+function isFileId(data, prefixes2) {
+  if (!prefixes2)
     return false;
-  return prefixes.some((prefix) => data.startsWith(prefix));
+  return prefixes2.some((prefix) => data.startsWith(prefix));
 }
 async function convertToOpenAIResponsesInput({
   prompt,
@@ -21775,8 +21882,8 @@ function mapAnthropicStopReason({
       return "other";
   }
 }
-function sanitizeJsonSchema(schema) {
-  return sanitizeSchema(schema);
+function sanitizeJsonSchema(schema2) {
+  return sanitizeSchema(schema2);
 }
 function sanitizeDefinition(definition) {
   if (typeof definition === "boolean" || !isPlainObject(definition)) {
@@ -21784,46 +21891,46 @@ function sanitizeDefinition(definition) {
   }
   return sanitizeSchema(definition);
 }
-function sanitizeSchema(schema) {
+function sanitizeSchema(schema2) {
   const result = {};
-  const schemaWithDefs = schema;
-  if (schema.$ref != null) {
-    return { $ref: schema.$ref };
+  const schemaWithDefs = schema2;
+  if (schema2.$ref != null) {
+    return { $ref: schema2.$ref };
   }
-  if (schema.$schema != null) {
-    result.$schema = schema.$schema;
+  if (schema2.$schema != null) {
+    result.$schema = schema2.$schema;
   }
-  if (schema.$id != null) {
-    result.$id = schema.$id;
+  if (schema2.$id != null) {
+    result.$id = schema2.$id;
   }
-  if (schema.title != null) {
-    result.title = schema.title;
+  if (schema2.title != null) {
+    result.title = schema2.title;
   }
-  if (schema.description != null) {
-    result.description = schema.description;
+  if (schema2.description != null) {
+    result.description = schema2.description;
   }
-  if (schema.default !== undefined) {
-    result.default = schema.default;
+  if (schema2.default !== undefined) {
+    result.default = schema2.default;
   }
-  if (schema.const !== undefined) {
-    result.const = schema.const;
+  if (schema2.const !== undefined) {
+    result.const = schema2.const;
   }
-  if (schema.enum != null) {
-    result.enum = schema.enum;
+  if (schema2.enum != null) {
+    result.enum = schema2.enum;
   }
-  if (schema.type != null) {
-    result.type = schema.type;
+  if (schema2.type != null) {
+    result.type = schema2.type;
   }
-  if (schema.anyOf != null) {
-    result.anyOf = schema.anyOf.map(sanitizeDefinition);
-  } else if (schema.oneOf != null) {
-    result.anyOf = schema.oneOf.map(sanitizeDefinition);
+  if (schema2.anyOf != null) {
+    result.anyOf = schema2.anyOf.map(sanitizeDefinition);
+  } else if (schema2.oneOf != null) {
+    result.anyOf = schema2.oneOf.map(sanitizeDefinition);
   }
-  if (schema.allOf != null) {
-    result.allOf = schema.allOf.map(sanitizeDefinition);
+  if (schema2.allOf != null) {
+    result.allOf = schema2.allOf.map(sanitizeDefinition);
   }
-  if (schema.definitions != null) {
-    result.definitions = Object.fromEntries(Object.entries(schema.definitions).map(([name22, definition]) => [
+  if (schema2.definitions != null) {
+    result.definitions = Object.fromEntries(Object.entries(schema2.definitions).map(([name22, definition]) => [
       name22,
       sanitizeDefinition(definition)
     ]));
@@ -21835,41 +21942,41 @@ function sanitizeSchema(schema) {
       sanitizeDefinition(definition)
     ]));
   }
-  if (schema.type === "object" || schema.properties != null) {
-    if (schema.properties != null) {
-      result.properties = Object.fromEntries(Object.entries(schema.properties).map(([name22, definition]) => [
+  if (schema2.type === "object" || schema2.properties != null) {
+    if (schema2.properties != null) {
+      result.properties = Object.fromEntries(Object.entries(schema2.properties).map(([name22, definition]) => [
         name22,
         sanitizeDefinition(definition)
       ]));
     }
     result.additionalProperties = false;
-    if (schema.required != null) {
-      result.required = schema.required;
+    if (schema2.required != null) {
+      result.required = schema2.required;
     }
   }
-  if (schema.items != null) {
-    result.items = Array.isArray(schema.items) ? schema.items.map(sanitizeDefinition) : sanitizeDefinition(schema.items);
+  if (schema2.items != null) {
+    result.items = Array.isArray(schema2.items) ? schema2.items.map(sanitizeDefinition) : sanitizeDefinition(schema2.items);
   }
-  if (typeof schema.format === "string" && SUPPORTED_STRING_FORMATS.has(schema.format)) {
-    result.format = schema.format;
+  if (typeof schema2.format === "string" && SUPPORTED_STRING_FORMATS.has(schema2.format)) {
+    result.format = schema2.format;
   }
-  const constraintDescription = getConstraintDescription(schema);
+  const constraintDescription = getConstraintDescription(schema2);
   if (constraintDescription != null) {
     result.description = result.description == null ? constraintDescription : `${result.description}
 ${constraintDescription}`;
   }
   return result;
 }
-function getConstraintDescription(schema) {
+function getConstraintDescription(schema2) {
   const descriptions = DESCRIPTION_CONSTRAINT_KEYS.flatMap((key) => {
-    const value = schema[key];
+    const value = schema2[key];
     if (value == null || value === false) {
       return [];
     }
     return `${formatConstraintName(key)}: ${formatConstraintValue(value)}`;
   });
-  if (typeof schema.format === "string" && !SUPPORTED_STRING_FORMATS.has(schema.format)) {
-    descriptions.push(`format: ${schema.format}`);
+  if (typeof schema2.format === "string" && !SUPPORTED_STRING_FORMATS.has(schema2.format)) {
+    descriptions.push(`format: ${schema2.format}`);
   }
   return descriptions.length === 0 ? undefined : `${descriptions.join("; ")}.`;
 }
@@ -25562,8 +25669,8 @@ function convertJSONSchemaToOpenAPISchema(jsonSchema2, isRoot = true) {
     result.allOf = allOf.map((item) => convertJSONSchemaToOpenAPISchema(item, false));
   }
   if (anyOf) {
-    if (anyOf.some((schema) => typeof schema === "object" && (schema == null ? undefined : schema.type) === "null")) {
-      const nonNullSchemas = anyOf.filter((schema) => !(typeof schema === "object" && (schema == null ? undefined : schema.type) === "null"));
+    if (anyOf.some((schema2) => typeof schema2 === "object" && (schema2 == null ? undefined : schema2.type) === "null")) {
+      const nonNullSchemas = anyOf.filter((schema2) => !(typeof schema2 === "object" && (schema2 == null ? undefined : schema2.type) === "null"));
       if (nonNullSchemas.length === 1) {
         const converted = convertJSONSchemaToOpenAPISchema(nonNullSchemas[0], false);
         if (typeof converted === "object") {
@@ -31781,13 +31888,13 @@ function parseIntersectionDef(def, refs) {
     })
   ].filter((x) => !!x);
   const mergedAllOf = [];
-  allOf.forEach((schema) => {
-    if (isJsonSchema7AllOfType(schema)) {
-      mergedAllOf.push(...schema.allOf);
+  allOf.forEach((schema2) => {
+    if (isJsonSchema7AllOfType(schema2)) {
+      mergedAllOf.push(...schema2.allOf);
     } else {
-      let nestedSchema = schema;
-      if ("additionalProperties" in schema && schema.additionalProperties === false) {
-        const { additionalProperties, ...rest } = schema;
+      let nestedSchema = schema2;
+      if ("additionalProperties" in schema2 && schema2.additionalProperties === false) {
+        const { additionalProperties, ...rest } = schema2;
         nestedSchema = rest;
       }
       mergedAllOf.push(nestedSchema);
@@ -31948,44 +32055,44 @@ function escapeNonAlphaNumeric(source) {
   }
   return result;
 }
-function addFormat(schema, value, message, refs) {
+function addFormat(schema2, value, message, refs) {
   var _a25;
-  if (schema.format || ((_a25 = schema.anyOf) == null ? undefined : _a25.some((x) => x.format))) {
-    if (!schema.anyOf) {
-      schema.anyOf = [];
+  if (schema2.format || ((_a25 = schema2.anyOf) == null ? undefined : _a25.some((x) => x.format))) {
+    if (!schema2.anyOf) {
+      schema2.anyOf = [];
     }
-    if (schema.format) {
-      schema.anyOf.push({
-        format: schema.format
+    if (schema2.format) {
+      schema2.anyOf.push({
+        format: schema2.format
       });
-      delete schema.format;
+      delete schema2.format;
     }
-    schema.anyOf.push({
+    schema2.anyOf.push({
       format: value,
       ...message && refs.errorMessages && { errorMessage: { format: message } }
     });
   } else {
-    schema.format = value;
+    schema2.format = value;
   }
 }
-function addPattern(schema, regex, message, refs) {
+function addPattern(schema2, regex, message, refs) {
   var _a25;
-  if (schema.pattern || ((_a25 = schema.allOf) == null ? undefined : _a25.some((x) => x.pattern))) {
-    if (!schema.allOf) {
-      schema.allOf = [];
+  if (schema2.pattern || ((_a25 = schema2.allOf) == null ? undefined : _a25.some((x) => x.pattern))) {
+    if (!schema2.allOf) {
+      schema2.allOf = [];
     }
-    if (schema.pattern) {
-      schema.allOf.push({
-        pattern: schema.pattern
+    if (schema2.pattern) {
+      schema2.allOf.push({
+        pattern: schema2.pattern
       });
-      delete schema.pattern;
+      delete schema2.pattern;
     }
-    schema.allOf.push({
+    schema2.allOf.push({
       pattern: stringifyRegExpWithFlags(regex, refs),
       ...message && refs.errorMessages && { errorMessage: { pattern: message } }
     });
   } else {
-    schema.pattern = stringifyRegExpWithFlags(regex, refs);
+    schema2.pattern = stringifyRegExpWithFlags(regex, refs);
   }
 }
 function stringifyRegExpWithFlags(regex, refs) {
@@ -32065,7 +32172,7 @@ function stringifyRegExpWithFlags(regex, refs) {
 }
 function parseRecordDef(def, refs) {
   var _a25, _b22, _c, _d, _e, _f;
-  const schema = {
+  const schema2 = {
     type: "object",
     additionalProperties: (_a25 = parseDef(def.valueType._def, {
       ...refs,
@@ -32075,12 +32182,12 @@ function parseRecordDef(def, refs) {
   if (((_b22 = def.keyType) == null ? undefined : _b22._def.typeName) === ZodFirstPartyTypeKind.ZodString && ((_c = def.keyType._def.checks) == null ? undefined : _c.length)) {
     const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
     return {
-      ...schema,
+      ...schema2,
       propertyNames: keyType
     };
   } else if (((_d = def.keyType) == null ? undefined : _d._def.typeName) === ZodFirstPartyTypeKind.ZodEnum) {
     return {
-      ...schema,
+      ...schema2,
       propertyNames: {
         enum: def.keyType._def.values
       }
@@ -32088,11 +32195,11 @@ function parseRecordDef(def, refs) {
   } else if (((_e = def.keyType) == null ? undefined : _e._def.typeName) === ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? undefined : _f.length)) {
     const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);
     return {
-      ...schema,
+      ...schema2,
       propertyNames: keyType
     };
   }
-  return schema;
+  return schema2;
 }
 function parseMapDef(def, refs) {
   if (refs.mapStrategy === "record") {
@@ -32285,9 +32392,9 @@ function decideAdditionalProperties(def, refs) {
       return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
   }
 }
-function safeIsOptional(schema) {
+function safeIsOptional(schema2) {
   try {
-    return schema.isOptional();
+    return schema2.isOptional();
   } catch (e) {
     return true;
   }
@@ -32300,18 +32407,18 @@ function parseSetDef(def, refs) {
     ...refs,
     currentPath: [...refs.currentPath, "items"]
   });
-  const schema = {
+  const schema2 = {
     type: "array",
     uniqueItems: true,
     items
   };
   if (def.minSize) {
-    schema.minItems = def.minSize.value;
+    schema2.minItems = def.minSize.value;
   }
   if (def.maxSize) {
-    schema.maxItems = def.maxSize.value;
+    schema2.maxItems = def.maxSize.value;
   }
-  return schema;
+  return schema2;
 }
 function parseTupleDef(def, refs) {
   if (def.rest) {
@@ -32378,12 +32485,12 @@ function parseDef(def, refs, forceResolution = false) {
   return jsonSchema2;
 }
 function lazySchema2(createSchema) {
-  let schema;
+  let schema2;
   return () => {
-    if (schema == null) {
-      schema = createSchema();
+    if (schema2 == null) {
+      schema2 = createSchema();
     }
-    return schema;
+    return schema2;
   };
 }
 function jsonSchema2(jsonSchema22, {
@@ -32404,8 +32511,8 @@ function jsonSchema2(jsonSchema22, {
 function isSchema(value) {
   return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true && "jsonSchema" in value && "validate" in value;
 }
-function asSchema2(schema) {
-  return schema == null ? jsonSchema2({ properties: {}, additionalProperties: false }) : isSchema(schema) ? schema : ("~standard" in schema) ? schema["~standard"].vendor === "zod" ? zodSchema2(schema) : standardSchema(schema) : schema();
+function asSchema2(schema2) {
+  return schema2 == null ? jsonSchema2({ properties: {}, additionalProperties: false }) : isSchema(schema2) ? schema2 : ("~standard" in schema2) ? schema2["~standard"].vendor === "zod" ? zodSchema2(schema2) : standardSchema(schema2) : schema2();
 }
 function standardSchema(standardSchema2) {
   return jsonSchema2(() => addAdditionalPropertiesToJsonSchema(standardSchema2["~standard"].jsonSchema.input({
@@ -32461,10 +32568,10 @@ function zodSchema2(zodSchema22, options) {
 }
 async function validateTypes2({
   value,
-  schema,
+  schema: schema2,
   context: context2
 }) {
-  const result = await safeValidateTypes2({ value, schema, context: context2 });
+  const result = await safeValidateTypes2({ value, schema: schema2, context: context2 });
   if (!result.success) {
     throw TypeValidationError2.wrap({ value, cause: result.error, context: context2 });
   }
@@ -32472,10 +32579,10 @@ async function validateTypes2({
 }
 async function safeValidateTypes2({
   value,
-  schema,
+  schema: schema2,
   context: context2
 }) {
-  const actualSchema = asSchema2(schema);
+  const actualSchema = asSchema2(schema2);
   try {
     if (actualSchema.validate == null) {
       return { success: true, value, rawValue: value };
@@ -32499,14 +32606,14 @@ async function safeValidateTypes2({
 }
 async function parseJSON2({
   text: text2,
-  schema
+  schema: schema2
 }) {
   try {
     const value = secureJsonParse(text2);
-    if (schema == null) {
+    if (schema2 == null) {
       return value;
     }
-    return validateTypes2({ value, schema });
+    return validateTypes2({ value, schema: schema2 });
   } catch (error) {
     if (JSONParseError.isInstance(error) || TypeValidationError2.isInstance(error)) {
       throw error;
@@ -32516,14 +32623,14 @@ async function parseJSON2({
 }
 async function safeParseJSON2({
   text: text2,
-  schema
+  schema: schema2
 }) {
   try {
     const value = secureJsonParse(text2);
-    if (schema == null) {
+    if (schema2 == null) {
       return { success: true, value, rawValue: value };
     }
-    return await safeValidateTypes2({ value, schema });
+    return await safeValidateTypes2({ value, schema: schema2 });
   } catch (error) {
     return {
       success: false,
@@ -32542,28 +32649,28 @@ function isParsableJson2(input) {
 }
 function parseJsonEventStream2({
   stream,
-  schema
+  schema: schema2
 }) {
   return stream.pipeThrough(new TextDecoderStream).pipeThrough(new EventSourceParserStream).pipeThrough(new TransformStream({
     async transform({ data }, controller) {
       if (data === "[DONE]") {
         return;
       }
-      controller.enqueue(await safeParseJSON2({ text: data, schema }));
+      controller.enqueue(await safeParseJSON2({ text: data, schema: schema2 }));
     }
   }));
 }
 async function parseProviderOptions2({
   provider,
   providerOptions,
-  schema
+  schema: schema2
 }) {
   if ((providerOptions == null ? undefined : providerOptions[provider]) == null) {
     return;
   }
   const parsedProviderOptions = await safeValidateTypes2({
     value: providerOptions[provider],
-    schema
+    schema: schema2
   });
   if (!parsedProviderOptions.success) {
     throw new InvalidArgumentError3({
@@ -32841,21 +32948,21 @@ var btoa, atob, name24 = "AI_DownloadError", marker24, symbol24, _a24, _b15, Dow
       }
     ]))
   };
-}, zod3ToJsonSchema = (schema, options) => {
+}, zod3ToJsonSchema = (schema2, options) => {
   var _a25;
   const refs = getRefs(options);
-  let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name33, schema2]) => {
+  let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name33, schema22]) => {
     var _a33;
     return {
       ...acc,
-      [name33]: (_a33 = parseDef(schema2._def, {
+      [name33]: (_a33 = parseDef(schema22._def, {
         ...refs,
         currentPath: [...refs.basePath, refs.definitionPath, name33]
       }, true)) != null ? _a33 : parseAnyDef()
     };
   }, {}) : undefined;
   const name25 = typeof options === "string" ? options : (options == null ? undefined : options.nameStrategy) === "title" ? undefined : options == null ? undefined : options.name;
-  const main = (_a25 = parseDef(schema._def, name25 === undefined ? refs : {
+  const main = (_a25 = parseDef(schema2._def, name25 === undefined ? refs : {
     ...refs,
     currentPath: [...refs.basePath, refs.definitionPath, name25]
   }, false)) != null ? _a25 : parseAnyDef();
@@ -33721,10 +33828,10 @@ function convertOpenAIResponsesUsage2(usage) {
     raw: usage
   };
 }
-function isFileId2(data, prefixes) {
-  if (!prefixes)
+function isFileId2(data, prefixes2) {
+  if (!prefixes2)
     return false;
-  return prefixes.some((prefix) => data.startsWith(prefix));
+  return prefixes2.some((prefix) => data.startsWith(prefix));
 }
 async function convertToOpenAIResponsesInput2({
   prompt,
@@ -40985,13 +41092,13 @@ function parseIntersectionDef2(def, refs) {
     }))
   ].filter((x) => !!x);
   const mergedAllOf = [];
-  allOf.forEach((schema) => {
-    if (isJsonSchema7AllOfType2(schema)) {
-      mergedAllOf.push(...schema.allOf);
+  allOf.forEach((schema2) => {
+    if (isJsonSchema7AllOfType2(schema2)) {
+      mergedAllOf.push(...schema2.allOf);
     } else {
-      let nestedSchema = schema;
-      if ("additionalProperties" in schema && schema.additionalProperties === false) {
-        const _a162 = schema, { additionalProperties } = _a162, rest = __objRest(_a162, ["additionalProperties"]);
+      let nestedSchema = schema2;
+      if ("additionalProperties" in schema2 && schema2.additionalProperties === false) {
+        const _a162 = schema2, { additionalProperties } = _a162, rest = __objRest(_a162, ["additionalProperties"]);
         nestedSchema = rest;
       }
       mergedAllOf.push(nestedSchema);
@@ -41152,42 +41259,42 @@ function escapeNonAlphaNumeric2(source) {
   }
   return result;
 }
-function addFormat2(schema, value, message, refs) {
+function addFormat2(schema2, value, message, refs) {
   var _a222;
-  if (schema.format || ((_a222 = schema.anyOf) == null ? undefined : _a222.some((x) => x.format))) {
-    if (!schema.anyOf) {
-      schema.anyOf = [];
+  if (schema2.format || ((_a222 = schema2.anyOf) == null ? undefined : _a222.some((x) => x.format))) {
+    if (!schema2.anyOf) {
+      schema2.anyOf = [];
     }
-    if (schema.format) {
-      schema.anyOf.push({
-        format: schema.format
+    if (schema2.format) {
+      schema2.anyOf.push({
+        format: schema2.format
       });
-      delete schema.format;
+      delete schema2.format;
     }
-    schema.anyOf.push(__spreadValues({
+    schema2.anyOf.push(__spreadValues({
       format: value
     }, message && refs.errorMessages && { errorMessage: { format: message } }));
   } else {
-    schema.format = value;
+    schema2.format = value;
   }
 }
-function addPattern2(schema, regex, message, refs) {
+function addPattern2(schema2, regex, message, refs) {
   var _a222;
-  if (schema.pattern || ((_a222 = schema.allOf) == null ? undefined : _a222.some((x) => x.pattern))) {
-    if (!schema.allOf) {
-      schema.allOf = [];
+  if (schema2.pattern || ((_a222 = schema2.allOf) == null ? undefined : _a222.some((x) => x.pattern))) {
+    if (!schema2.allOf) {
+      schema2.allOf = [];
     }
-    if (schema.pattern) {
-      schema.allOf.push({
-        pattern: schema.pattern
+    if (schema2.pattern) {
+      schema2.allOf.push({
+        pattern: schema2.pattern
       });
-      delete schema.pattern;
+      delete schema2.pattern;
     }
-    schema.allOf.push(__spreadValues({
+    schema2.allOf.push(__spreadValues({
       pattern: stringifyRegExpWithFlags2(regex, refs)
     }, message && refs.errorMessages && { errorMessage: { pattern: message } }));
   } else {
-    schema.pattern = stringifyRegExpWithFlags2(regex, refs);
+    schema2.pattern = stringifyRegExpWithFlags2(regex, refs);
   }
 }
 function stringifyRegExpWithFlags2(regex, refs) {
@@ -41267,7 +41374,7 @@ function stringifyRegExpWithFlags2(regex, refs) {
 }
 function parseRecordDef2(def, refs) {
   var _a222, _b222, _c, _d, _e, _f;
-  const schema = {
+  const schema2 = {
     type: "object",
     additionalProperties: (_a222 = parseDef2(def.valueType._def, __spreadProps(__spreadValues({}, refs), {
       currentPath: [...refs.currentPath, "additionalProperties"]
@@ -41275,22 +41382,22 @@ function parseRecordDef2(def, refs) {
   };
   if (((_b222 = def.keyType) == null ? undefined : _b222._def.typeName) === ZodFirstPartyTypeKind.ZodString && ((_c = def.keyType._def.checks) == null ? undefined : _c.length)) {
     const _a162 = parseStringDef2(def.keyType._def, refs), { type } = _a162, keyType = __objRest(_a162, ["type"]);
-    return __spreadProps(__spreadValues({}, schema), {
+    return __spreadProps(__spreadValues({}, schema2), {
       propertyNames: keyType
     });
   } else if (((_d = def.keyType) == null ? undefined : _d._def.typeName) === ZodFirstPartyTypeKind.ZodEnum) {
-    return __spreadProps(__spreadValues({}, schema), {
+    return __spreadProps(__spreadValues({}, schema2), {
       propertyNames: {
         enum: def.keyType._def.values
       }
     });
   } else if (((_e = def.keyType) == null ? undefined : _e._def.typeName) === ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind.ZodString && ((_f = def.keyType._def.type._def.checks) == null ? undefined : _f.length)) {
     const _b16 = parseBrandedDef2(def.keyType._def, refs), { type } = _b16, keyType = __objRest(_b16, ["type"]);
-    return __spreadProps(__spreadValues({}, schema), {
+    return __spreadProps(__spreadValues({}, schema2), {
       propertyNames: keyType
     });
   }
-  return schema;
+  return schema2;
 }
 function parseMapDef2(def, refs) {
   if (refs.mapStrategy === "record") {
@@ -41478,9 +41585,9 @@ function decideAdditionalProperties2(def, refs) {
       return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
   }
 }
-function safeIsOptional2(schema) {
+function safeIsOptional2(schema2) {
   try {
-    return schema.isOptional();
+    return schema2.isOptional();
   } catch (e) {
     return true;
   }
@@ -41492,18 +41599,18 @@ function parseSetDef2(def, refs) {
   const items = parseDef2(def.valueType._def, __spreadProps(__spreadValues({}, refs), {
     currentPath: [...refs.currentPath, "items"]
   }));
-  const schema = {
+  const schema2 = {
     type: "array",
     uniqueItems: true,
     items
   };
   if (def.minSize) {
-    schema.minItems = def.minSize.value;
+    schema2.minItems = def.minSize.value;
   }
   if (def.maxSize) {
-    schema.maxItems = def.maxSize.value;
+    schema2.maxItems = def.maxSize.value;
   }
-  return schema;
+  return schema2;
 }
 function parseTupleDef2(def, refs) {
   if (def.rest) {
@@ -41584,8 +41691,8 @@ function jsonSchema3(jsonSchema22, {
 function isSchema2(value) {
   return typeof value === "object" && value !== null && schemaSymbol2 in value && value[schemaSymbol2] === true && "jsonSchema" in value && "validate" in value;
 }
-function asSchema3(schema) {
-  return schema == null ? jsonSchema3({ properties: {}, additionalProperties: false }) : isSchema2(schema) ? schema : ("~standard" in schema) ? schema["~standard"].vendor === "zod" ? zodSchema3(schema) : standardSchema2(schema) : schema();
+function asSchema3(schema2) {
+  return schema2 == null ? jsonSchema3({ properties: {}, additionalProperties: false }) : isSchema2(schema2) ? schema2 : ("~standard" in schema2) ? schema2["~standard"].vendor === "zod" ? zodSchema3(schema2) : standardSchema2(schema2) : schema2();
 }
 function standardSchema2(standardSchema22) {
   return jsonSchema3(() => addAdditionalPropertiesToJsonSchema2(standardSchema22["~standard"].jsonSchema.input({
@@ -41641,10 +41748,10 @@ function zodSchema3(zodSchema22, options) {
 }
 async function validateTypes3({
   value,
-  schema,
+  schema: schema2,
   context: context2
 }) {
-  const result = await safeValidateTypes3({ value, schema, context: context2 });
+  const result = await safeValidateTypes3({ value, schema: schema2, context: context2 });
   if (!result.success) {
     throw TypeValidationError3.wrap({ value, cause: result.error, context: context2 });
   }
@@ -41652,10 +41759,10 @@ async function validateTypes3({
 }
 async function safeValidateTypes3({
   value,
-  schema,
+  schema: schema2,
   context: context2
 }) {
-  const actualSchema = asSchema3(schema);
+  const actualSchema = asSchema3(schema2);
   try {
     if (actualSchema.validate == null) {
       return { success: true, value, rawValue: value };
@@ -41679,14 +41786,14 @@ async function safeValidateTypes3({
 }
 async function parseJSON3({
   text: text2,
-  schema
+  schema: schema2
 }) {
   try {
     const value = secureJsonParse2(text2);
-    if (schema == null) {
+    if (schema2 == null) {
       return value;
     }
-    return validateTypes3({ value, schema });
+    return validateTypes3({ value, schema: schema2 });
   } catch (error) {
     if (JSONParseError2.isInstance(error) || TypeValidationError3.isInstance(error)) {
       throw error;
@@ -41696,14 +41803,14 @@ async function parseJSON3({
 }
 async function safeParseJSON3({
   text: text2,
-  schema
+  schema: schema2
 }) {
   try {
     const value = secureJsonParse2(text2);
-    if (schema == null) {
+    if (schema2 == null) {
       return { success: true, value, rawValue: value };
     }
-    return await safeValidateTypes3({ value, schema });
+    return await safeValidateTypes3({ value, schema: schema2 });
   } catch (error) {
     return {
       success: false,
@@ -41722,14 +41829,14 @@ function isParsableJson3(input) {
 }
 function parseJsonEventStream3({
   stream,
-  schema
+  schema: schema2
 }) {
   return stream.pipeThrough(new TextDecoderStream).pipeThrough(new EventSourceParserStream2).pipeThrough(new TransformStream({
     async transform({ data }, controller) {
       if (data === "[DONE]") {
         return;
       }
-      controller.enqueue(await safeParseJSON3({ text: data, schema }));
+      controller.enqueue(await safeParseJSON3({ text: data, schema: schema2 }));
     }
   }));
 }
@@ -42939,19 +43046,19 @@ var __defProp2, __defProps, __getOwnPropDescs, __getOwnPropSymbols, __hasOwnProp
       }
     ]))
   });
-}, zod3ToJsonSchema2 = (schema, options) => {
+}, zod3ToJsonSchema2 = (schema2, options) => {
   var _a222;
   const refs = getRefs2(options);
-  let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name322, schema2]) => {
+  let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name322, schema22]) => {
     var _a322;
     return __spreadProps(__spreadValues({}, acc), {
-      [name322]: (_a322 = parseDef2(schema2._def, __spreadProps(__spreadValues({}, refs), {
+      [name322]: (_a322 = parseDef2(schema22._def, __spreadProps(__spreadValues({}, refs), {
         currentPath: [...refs.basePath, refs.definitionPath, name322]
       }), true)) != null ? _a322 : parseAnyDef2()
     });
   }, {}) : undefined;
   const name222 = typeof options === "string" ? options : (options == null ? undefined : options.nameStrategy) === "title" ? undefined : options == null ? undefined : options.name;
-  const main = (_a222 = parseDef2(schema._def, name222 === undefined ? refs : __spreadProps(__spreadValues({}, refs), {
+  const main = (_a222 = parseDef2(schema2._def, name222 === undefined ? refs : __spreadProps(__spreadValues({}, refs), {
     currentPath: [...refs.basePath, refs.definitionPath, name222]
   }), false)) != null ? _a222 : parseAnyDef2();
   const title = typeof options === "object" && options.name !== undefined && options.nameStrategy === "title" ? options.name : undefined;
@@ -45326,77 +45433,123 @@ Error message: ${getErrorMessage4(cause)}`,
   });
 });
 
-// src/core/id/id.ts
-import { randomBytes } from "node:crypto";
-function schema(prefix) {
-  return zod_default.string().startsWith(prefixes[prefix]);
+// src/core/observability/active-root-spans.ts
+function registerActiveRootSpan(span) {
+  activeRootSpans.add(span);
 }
-function descending(prefix, given) {
-  return generateID(prefix, true, given);
-}
-function generateID(prefix, descending2, given) {
-  if (!given) {
-    return create(prefix, descending2);
-  }
-  if (!given.startsWith(prefixes[prefix])) {
-    throw new Error(`ID ${given} does not start with ${prefixes[prefix]}`);
-  }
-  return given;
+function unregisterActiveRootSpan(span) {
+  activeRootSpans.delete(span);
 }
-function randomBase62(length) {
-  const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-  let result = "";
-  const bytes = randomBytes(length);
-  for (let i = 0;i < length; i++) {
-    result += chars[bytes[i] % 62];
+function endAllActiveRootSpans() {
+  for (const span of activeRootSpans) {
+    try {
+      span.end();
+    } catch {}
   }
-  return result;
+  activeRootSpans.clear();
 }
-function create(prefix, descending2, timestamp) {
-  const currentTimestamp = timestamp ?? Date.now();
-  if (currentTimestamp !== lastTimestamp) {
-    lastTimestamp = currentTimestamp;
-    counter = 0;
-  }
-  counter++;
-  let now2 = BigInt(currentTimestamp) * BigInt(4096) + BigInt(counter);
-  now2 = descending2 ? ~now2 : now2;
-  const timeBytes = Buffer.alloc(6);
-  for (let i = 0;i < 6; i++) {
-    timeBytes[i] = Number(now2 >> BigInt(40 - 8 * i) & BigInt(255));
-  }
-  return prefixes[prefix] + "_" + timeBytes.toString("hex") + randomBase62(LENGTH - 12);
+var activeRootSpans;
+var init_active_root_spans = __esm(() => {
+  activeRootSpans = new Set;
+});
+
+// src/core/observability/telemetry.ts
+function createAiTelemetrySettings(input) {
+  const recordPayloads = shouldRecordAiPayloads();
+  const metadata = {};
+  if (input.sessionId)
+    metadata.sessionId = input.sessionId;
+  return {
+    isEnabled: true,
+    recordInputs: recordPayloads,
+    recordOutputs: recordPayloads,
+    functionId: input.operation,
+    ...Object.keys(metadata).length > 0 ? { metadata } : {}
+  };
 }
-var prefixes, LENGTH = 26, lastTimestamp = 0, counter = 0, newSessionId = () => descending("session"), newMessageId = () => descending("message"), newPartId = () => descending("part"), isSessionId = (s) => s.startsWith(`${prefixes.session}_`);
-var init_id = __esm(() => {
-  init_zod();
-  prefixes = {
-    session: "ses",
-    message: "msg",
-    permission: "per",
-    user: "usr",
-    part: "prt"
+function describeFailure(error) {
+  if (error instanceof Error)
+    return error.message;
+  if (typeof error === "string")
+    return error;
+  try {
+    return JSON.stringify(error) || String(error);
+  } catch {
+    return String(error);
+  }
+}
+function createGenerationSpanTracker() {
+  const inner = import_api3.trace.getTracer("ai");
+  let rootSpan = null;
+  const tracer = {
+    startSpan: (name27, options, context2) => {
+      const span = inner.startSpan(name27, options, context2);
+      if (name27 === "ai.streamText")
+        rootSpan = span;
+      return span;
+    },
+    startActiveSpan: (name27, ...rest) => {
+      const callback = rest[rest.length - 1];
+      const capture = (span, ...restArgs) => {
+        if (name27 === "ai.streamText")
+          rootSpan = span;
+        return callback(span, ...restArgs);
+      };
+      const forwardArgs = [...rest.slice(0, -1), capture];
+      return inner.startActiveSpan.call(inner, name27, ...forwardArgs);
+    }
+  };
+  let marked = false;
+  return {
+    tracer,
+    markFailed(error) {
+      const span = rootSpan;
+      if (!span || marked)
+        return;
+      marked = true;
+      const message = describeFailure(error);
+      span.recordException(error instanceof Error ? error : message);
+      span.setStatus({ code: import_api3.SpanStatusCode.ERROR, message });
+    }
   };
+}
+var import_api3;
+var init_telemetry = __esm(() => {
+  init_observability();
+  import_api3 = __toESM(require_src(), 1);
 });
 
-// src/core/observability.ts
+// src/core/observability/index.ts
+import { AsyncLocalStorage } from "node:async_hooks";
 function getApexTracer() {
-  return import_api3.trace.getTracer("apex");
+  return import_api4.trace.getTracer("apex");
 }
 function shouldRecordAiPayloads() {
+  const override = aiPayloadCaptureStore.getStore();
+  if (override !== undefined)
+    return override;
   return process.env.AI_TRACE_RECORD_PAYLOADS === "true";
 }
 function withSubagentSessionBaggage(sessionId, fn) {
   if (!sessionId || !isSessionId(sessionId) || sessionId.includes("-")) {
     return fn();
   }
-  const baggage = (import_api3.propagation.getActiveBaggage() ?? import_api3.propagation.createBaggage()).setEntry(SESSION_BAGGAGE_KEY, { value: sessionId });
-  return import_api3.context.with(import_api3.propagation.setBaggage(import_api3.context.active(), baggage), fn);
+  const baggage = (import_api4.propagation.getActiveBaggage() ?? import_api4.propagation.createBaggage()).setEntry(SESSION_BAGGAGE_KEY, { value: sessionId });
+  return import_api4.context.with(import_api4.propagation.setBaggage(import_api4.context.active(), baggage), fn);
+}
+function getActiveTraceCorrelation() {
+  const spanContext = import_api4.trace.getSpan(import_api4.context.active())?.spanContext();
+  if (!spanContext || !import_api4.trace.isSpanContextValid(spanContext))
+    return null;
+  return { traceId: spanContext.traceId, spanId: spanContext.spanId };
 }
-var import_api3, SESSION_BAGGAGE_KEY = "pensar.session.id";
+var import_api4, aiPayloadCaptureStore, SESSION_BAGGAGE_KEY = "pensar.session.id";
 var init_observability = __esm(() => {
   init_id();
-  import_api3 = __toESM(require_src(), 1);
+  init_active_root_spans();
+  init_telemetry();
+  import_api4 = __toESM(require_src(), 1);
+  aiPayloadCaptureStore = new AsyncLocalStorage;
 });
 
 // src/core/ai/caching.ts
@@ -45820,7 +45973,30 @@ var init_streamTelemetry = __esm(() => {
 });
 
 // src/core/ai/ai.ts
-import { AsyncLocalStorage } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+function isRepairFailClosedTool(toolName) {
+  return REPAIR_FAIL_CLOSED_TOOLS.has(toolName);
+}
+function normalizeStepUsage(step) {
+  const inputTokens = step.usage?.inputTokens ?? 0;
+  const outputTokens = step.usage?.outputTokens ?? 0;
+  const meta = step.providerMetadata?.anthropic;
+  let cacheRead = meta?.cacheReadInputTokens ?? 0;
+  let cacheWrite = meta?.cacheCreationInputTokens ?? 0;
+  const details = step.usage?.inputTokenDetails;
+  if (cacheRead === 0) {
+    cacheRead = details?.cacheReadTokens ?? 0;
+  }
+  if (cacheWrite === 0) {
+    cacheWrite = details?.cacheWriteTokens ?? 0;
+  }
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens: cacheRead,
+    cacheWriteTokens: cacheWrite
+  };
+}
 function takeStepContext() {
   const store = stepContextStore.getStore();
   if (!store)
@@ -45916,7 +46092,7 @@ function createToolExecutionGate() {
     }
   };
 }
-function wrapStreamWithErrorHandler(originalStream, messagesContainer, opts, model, silent, rateLimitRetryCount = 0, idleResumeCount = 0) {
+function wrapStreamWithErrorHandler(originalStream, messagesContainer, opts, model, silent, rateLimitRetryCount = 0, idleResumeCount = 0, generationSpans) {
   let wrappedStream = null;
   const handler = {
     get(_target, prop) {
@@ -45924,6 +46100,7 @@ function wrapStreamWithErrorHandler(originalStream, messagesContainer, opts, mod
         if (!wrappedStream) {
           const toolGate = createToolExecutionGate();
           wrappedStream = async function* () {
+            let streamError;
             try {
               for await (const chunk of withIdleTimeout(originalStream.fullStream, STREAM_IDLE_TIMEOUT_MS, toolGate.shouldEnforceIdleTimeout)) {
                 toolGate.observe(chunk);
@@ -45936,11 +46113,22 @@ function wrapStreamWithErrorHandler(originalStream, messagesContainer, opts, mod
                   }
                 }
                 if (chunk.type === "error") {
-                  throw chunk.error;
+                  streamError = chunk.error;
+                  generationSpans?.markFailed(streamError);
+                  continue;
+                }
+                if (streamError !== undefined) {
+                  continue;
                 }
                 yield chunk;
               }
-            } catch (error) {
+              if (streamError !== undefined) {
+                await Promise.resolve(originalStream.response).catch(() => {});
+                throw streamError;
+              }
+            } catch (caughtError) {
+              const error = streamError !== undefined ? streamError : caughtError;
+              generationSpans?.markFailed(error);
               const errorMessage = error instanceof Error ? error.message : String(error);
               const isCtxError = checkIfContextLengthError(error);
               if (!isCtxError && isStreamIdleTimeoutError(error) && idleResumeCount < MAX_IDLE_RESUME_RETRIES && messagesContainer.current.length > 0) {
@@ -46095,6 +46283,18 @@ function normalizeOpenAIReasoningEffort(modelId, effort) {
   }
   return DEFAULT_OPENAI_REASONING_EFFORT;
 }
+function buildOpenRouterProviderOptions(model) {
+  if (model !== "z-ai/glm-5.2")
+    return;
+  return {
+    openrouter: {
+      provider: {
+        only: ["z-ai"],
+        allow_fallbacks: false
+      }
+    }
+  };
+}
 function buildReasoningProviderOptions(model, opts) {
   const useThinking = !!opts.enableThinking && isAnthropicProvider(model) && modelSupportsAdaptiveThinking(model);
   const normalizedOpenAIEffort = normalizeOpenAIReasoningEffort(model, opts.openAIReasoningEffort);
@@ -46132,6 +46332,8 @@ function streamResponse(opts) {
     toolChoice,
     tools,
     onStepFinish: userOnStepFinish,
+    languageModelMiddleware,
+    usageRecorder,
     abortSignal,
     activeTools,
     silent,
@@ -46144,16 +46346,35 @@ function streamResponse(opts) {
     sessionId
   } = opts;
   const onStepFinish = async (step) => {
+    const stepUsage = normalizeStepUsage(step);
+    if (onCacheMetrics && (stepUsage.cacheReadTokens > 0 || stepUsage.cacheWriteTokens > 0)) {
+      await onCacheMetrics({
+        cacheReadInputTokens: stepUsage.cacheReadTokens,
+        cacheCreationInputTokens: stepUsage.cacheWriteTokens
+      });
+    }
     await userOnStepFinish?.(step);
-    if (_usageCallback) {
-      const inp = step.usage?.inputTokens ?? 0;
-      const out = step.usage?.outputTokens ?? 0;
+    if (usageRecorder || _usageCallback) {
       const stepCtx = takeStepContext();
-      if (inp > 0 || out > 0)
-        _usageCallback(model, inp, out, stepCtx);
+      if (stepUsage.inputTokens > 0 || stepUsage.outputTokens > 0) {
+        const usageContext = {
+          ...stepCtx,
+          cacheReadTokens: stepUsage.cacheReadTokens,
+          cacheWriteTokens: stepUsage.cacheWriteTokens
+        };
+        if (usageRecorder) {
+          await usageRecorder(model, stepUsage.inputTokens, stepUsage.outputTokens, usageContext);
+        } else {
+          await _usageCallback?.(model, stepUsage.inputTokens, stepUsage.outputTokens, usageContext);
+        }
+      }
     }
   };
-  const providerModel = getProviderModel(model, authConfig);
+  const baseProviderModel = getProviderModel(model, authConfig);
+  const providerModel = languageModelMiddleware ? wrapLanguageModel({
+    model: baseProviderModel,
+    middleware: languageModelMiddleware
+  }) : baseProviderModel;
   const cacheBreakpoint = cacheBreakpointFor(model);
   const systemWithToolPolicy = applySequentialToolCallPolicy(system, tools, model);
   let fittedMessages = messages;
@@ -46188,14 +46409,16 @@ function streamResponse(opts) {
     effectiveMessages = withCachedSystemPrompt(systemWithToolPolicy, baseMessages, cacheBreakpoint);
     effectiveSystem = undefined;
   }
-  const providerOptions = buildReasoningProviderOptions(model, {
+  const reasoningProviderOptions = buildReasoningProviderOptions(model, {
     enableThinking,
     thinkingEffort,
     openAIReasoningEffort
   });
+  const openRouterProviderOptions = buildOpenRouterProviderOptions(model);
+  const providerOptions = reasoningProviderOptions || openRouterProviderOptions ? { ...reasoningProviderOptions, ...openRouterProviderOptions } : undefined;
   let rateLimitRetryCount = 0;
   try {
-    const recordPayloads = shouldRecordAiPayloads();
+    const generationSpans = createGenerationSpanTracker();
     const response = streamText({
       model: providerModel,
       system: effectiveSystem,
@@ -46206,11 +46429,11 @@ function streamResponse(opts) {
       maxRetries: 3,
       providerOptions,
       experimental_telemetry: {
-        isEnabled: true,
-        recordInputs: recordPayloads,
-        recordOutputs: recordPayloads,
-        functionId: `apex.stream.${model}`,
-        ...sessionId ? { metadata: { sessionId } } : {}
+        ...createAiTelemetrySettings({
+          operation: "apex.agent.stream",
+          sessionId
+        }),
+        tracer: generationSpans.tracer
       },
       maxOutputTokens: getMaxOutputTokens(model),
       prepareStep: (opts2) => {
@@ -46227,31 +46450,9 @@ function streamResponse(opts) {
         if (errorMessage.toLowerCase().includes("too many tokens") || errorMessage.toLowerCase().includes("overloaded")) {
           rateLimitRetryCount++;
           await new Promise((resolve2) => setTimeout(resolve2, 1000 * rateLimitRetryCount));
-          if (rateLimitRetryCount < 20) {
-            return;
-          }
         }
-        throw error;
       },
-      onStepFinish: onCacheMetrics ? (stepResult) => {
-        const meta = stepResult.providerMetadata?.anthropic;
-        let cacheRead = meta?.cacheReadInputTokens ?? 0;
-        let cacheCreation = meta?.cacheCreationInputTokens ?? 0;
-        const { inputTokenDetails } = stepResult.usage;
-        if (cacheRead === 0) {
-          cacheRead = inputTokenDetails?.cacheReadTokens ?? 0;
-        }
-        if (cacheCreation === 0) {
-          cacheCreation = inputTokenDetails?.cacheWriteTokens ?? 0;
-        }
-        if (cacheRead > 0 || cacheCreation > 0) {
-          onCacheMetrics({
-            cacheReadInputTokens: cacheRead,
-            cacheCreationInputTokens: cacheCreation
-          });
-        }
-        onStepFinish?.(stepResult);
-      } : onStepFinish,
+      onStepFinish,
       abortSignal,
       activeTools,
       experimental_repairToolCall: async ({
@@ -46265,6 +46466,12 @@ function streamResponse(opts) {
           const rawLen = typeof raw === "string" ? raw.length : JSON.stringify(raw).length;
           log.warn(`[response-debug] experimental_repairToolCall FIRED for response ` + `rawInputChars=${rawLen} error=${(error.message || String(error)).slice(0, 200)}`);
         }
+        if (isRepairFailClosedTool(toolCall.toolName)) {
+          if (!silent) {
+            log.warn(`Tool-call repair disabled for security-sensitive tool "${toolCall.toolName}" — failing closed (no argument synthesis).`);
+          }
+          return null;
+        }
         try {
           if (!silent) {
             log.debug(`Repairing tool call: ${toolCall.toolName}`, {
@@ -46286,7 +46493,11 @@ function streamResponse(opts) {
           const inputAsText = typeof rawInput === "string" ? rawInput : JSON.stringify(rawInput);
           const boundedInput = truncateWithMarker(inputAsText, MAX_TOOL_INPUT_CHARS);
           const boundedSchema = truncateWithMarker(JSON.stringify(jsonSchema4), MAX_SCHEMA_CHARS, "schema");
-          const { output: repairedArgs, usage: repairUsage } = await generateText({
+          const {
+            output: repairedArgs,
+            usage: repairUsage,
+            providerMetadata: repairProviderMetadata
+          } = await generateText({
             model: providerModel,
             output: output_exports.object({
               schema: tool4.inputSchema
@@ -46304,41 +46515,47 @@ function streamResponse(opts) {
             ].join(`
 `),
             abortSignal,
-            experimental_telemetry: {
-              isEnabled: true,
-              recordInputs: recordPayloads,
-              recordOutputs: recordPayloads,
-              functionId: "apex.tool_repair",
-              ...sessionId ? { metadata: { sessionId } } : {}
-            }
+            experimental_telemetry: createAiTelemetrySettings({
+              operation: "apex.tool.repair",
+              sessionId
+            })
           });
           if (onStepFinish && repairUsage) {
-            onStepFinish({
-              text: "",
-              reasoning: undefined,
-              reasoningDetails: [],
-              files: [],
-              sources: [],
-              toolCalls: [],
-              toolResults: [],
-              finishReason: "stop",
-              usage: {
-                inputTokens: repairUsage.inputTokens ?? 0,
-                outputTokens: repairUsage.outputTokens ?? 0,
-                totalTokens: repairUsage.totalTokens ?? 0
-              },
-              warnings: [],
-              request: {},
-              response: {
-                id: "tool-repair",
-                timestamp: new Date,
-                modelId: "",
-                messages: []
-              },
-              providerMetadata: undefined,
-              stepType: "initial",
-              isContinued: false
-            });
+            try {
+              await onStepFinish({
+                text: "",
+                reasoning: undefined,
+                reasoningDetails: [],
+                files: [],
+                sources: [],
+                toolCalls: [],
+                toolResults: [],
+                finishReason: "stop",
+                usage: {
+                  inputTokens: repairUsage.inputTokens ?? 0,
+                  outputTokens: repairUsage.outputTokens ?? 0,
+                  totalTokens: repairUsage.totalTokens ?? 0,
+                  ...repairUsage.inputTokenDetails ? { inputTokenDetails: repairUsage.inputTokenDetails } : {}
+                },
+                warnings: [],
+                request: {},
+                response: {
+                  id: "tool-repair",
+                  timestamp: new Date,
+                  modelId: "",
+                  messages: messagesContainer.current
+                },
+                providerMetadata: repairProviderMetadata,
+                stepType: "initial",
+                isContinued: false
+              });
+            } catch (callbackError) {
+              if (!silent) {
+                log.warn("Error reporting tool repair usage", {
+                  error: String(callbackError)
+                });
+              }
+            }
           }
           if (repairedArgs === undefined || repairedArgs === null) {
             if (!silent) {
@@ -46358,7 +46575,7 @@ function streamResponse(opts) {
       },
       onFinish
     });
-    return wrapStreamWithErrorHandler(response, messagesContainer, opts, providerModel, silent);
+    return wrapStreamWithErrorHandler(response, messagesContainer, opts, providerModel, silent, 0, 0, generationSpans);
   } catch (error) {
     const isContextLengthError = checkIfContextLengthError(error);
     const outerErrorMessage = error instanceof Error ? error.message : String(error);
@@ -46392,11 +46609,11 @@ async function generateObjectResponse(opts) {
   } = opts;
   const providerModel = getProviderModel(model, authConfig);
   const normalizedOpenAIEffort = normalizeOpenAIReasoningEffort(model, openAIReasoningEffort);
+  const openRouterProviderOptions = buildOpenRouterProviderOptions(model);
   let lastError;
   for (let attempt = 0;attempt <= MAX_OBJECT_RATE_LIMIT_RETRIES; attempt++) {
     try {
-      const recordPayloads = shouldRecordAiPayloads();
-      const { output, usage } = await generateText({
+      const { output, usage, providerMetadata } = await generateText({
         model: providerModel,
         output: output_exports.object({
           schema: schema2
@@ -46405,30 +46622,34 @@ async function generateObjectResponse(opts) {
         system,
         maxOutputTokens: maxTokens,
         temperature,
-        providerOptions: normalizedOpenAIEffort ? {
-          openai: {
-            reasoningEffort: normalizedOpenAIEffort
-          }
+        providerOptions: normalizedOpenAIEffort || openRouterProviderOptions ? {
+          ...normalizedOpenAIEffort ? {
+            openai: {
+              reasoningEffort: normalizedOpenAIEffort
+            }
+          } : {},
+          ...openRouterProviderOptions
         } : undefined,
         maxRetries: 0,
         abortSignal,
-        experimental_telemetry: {
-          isEnabled: true,
-          recordInputs: recordPayloads,
-          recordOutputs: recordPayloads,
-          functionId: "apex.generate_object",
-          ...sessionId ? { metadata: { sessionId } } : {}
-        }
+        experimental_telemetry: createAiTelemetrySettings({
+          operation: opts.operation ?? "apex.structured.generate",
+          sessionId
+        })
       });
       if (onTokenUsage && usage) {
         onTokenUsage(usage.inputTokens ?? 0, usage.outputTokens ?? 0);
       }
       if (_usageCallback && usage) {
-        const inp = usage.inputTokens ?? 0;
-        const out = usage.outputTokens ?? 0;
+        const stepUsage = normalizeStepUsage({ usage, providerMetadata });
         const stepCtx = takeStepContext();
-        if (inp > 0 || out > 0)
-          _usageCallback(model, inp, out, stepCtx);
+        if (stepUsage.inputTokens > 0 || stepUsage.outputTokens > 0) {
+          await _usageCallback(model, stepUsage.inputTokens, stepUsage.outputTokens, {
+            ...stepCtx,
+            cacheReadTokens: stepUsage.cacheReadTokens,
+            cacheWriteTokens: stepUsage.cacheWriteTokens
+          });
+        }
       }
       return output;
     } catch (error) {
@@ -46447,7 +46668,7 @@ async function generateObjectResponse(opts) {
   }
   throw lastError;
 }
-var log, RESPONSE_DEBUG, RESPONSE_TOOL_NAME = "response", DEFAULT_OPENAI_REASONING_EFFORT = "medium", OPENAI_REASONING_MODEL_IDS, _usageCallback = null, stepContextStore, SEQUENTIAL_TOOL_CALL_INSTRUCTION, MAX_RATE_LIMIT_RETRIES = 20, MAX_IDLE_RESUME_RETRIES = 3, STREAM_IDLE_TIMEOUT_MS, StreamIdleTimeoutError, NON_GATED_TOOLS, MAX_OBJECT_RATE_LIMIT_RETRIES = 8, ContextLengthError, ContextLengthExhaustedError, MAX_RESTART_DEPTH = 3, MAX_TOOL_INPUT_CHARS = 8000, MAX_SCHEMA_CHARS = 6000, MINIMAL_RESTART_PROMPT = "Continue the previous task. Earlier context was discarded due to repeated context-length errors.";
+var log, RESPONSE_DEBUG, RESPONSE_TOOL_NAME = "response", REPAIR_FAIL_CLOSED_TOOLS, DEFAULT_OPENAI_REASONING_EFFORT = "medium", OPENAI_REASONING_MODEL_IDS, _usageCallback = null, stepContextStore, SEQUENTIAL_TOOL_CALL_INSTRUCTION, MAX_RATE_LIMIT_RETRIES = 20, MAX_IDLE_RESUME_RETRIES = 3, STREAM_IDLE_TIMEOUT_MS, StreamIdleTimeoutError, NON_GATED_TOOLS, MAX_OBJECT_RATE_LIMIT_RETRIES = 8, ContextLengthError, ContextLengthExhaustedError, MAX_RESTART_DEPTH = 3, MAX_TOOL_INPUT_CHARS = 8000, MAX_SCHEMA_CHARS = 6000, MINIMAL_RESTART_PROMPT = "Continue the previous task. Earlier context was discarded due to repeated context-length errors.";
 var init_ai = __esm(() => {
   init_dist4();
   init_structured();
@@ -46460,6 +46681,9 @@ var init_ai = __esm(() => {
   init_utils();
   log = scopedLogger(() => createLogger("ai"));
   RESPONSE_DEBUG = process.env.RESPONSE_DEBUG === "1" || process.env.RESPONSE_DEBUG === "true";
+  REPAIR_FAIL_CLOSED_TOOLS = new Set([
+    "spawn_pentest_agent"
+  ]);
   OPENAI_REASONING_MODEL_IDS = new Set([
     "gpt-5",
     "gpt-5-2025-08-07",
@@ -46479,7 +46703,7 @@ var init_ai = __esm(() => {
     "gpt-5.6-terra",
     "gpt-5.6-luna"
   ]);
-  stepContextStore = new AsyncLocalStorage;
+  stepContextStore = new AsyncLocalStorage2;
   SEQUENTIAL_TOOL_CALL_INSTRUCTION = "CRITICAL TOOL-CALLING RULE: Emit EXACTLY ONE tool call per response. " + "Never emit more than one tool call in a single turn. After each tool call, " + "wait for its result before making the next one. Emitting multiple tool " + "calls in one turn corrupts their arguments.";
   STREAM_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
   StreamIdleTimeoutError = class StreamIdleTimeoutError extends Error {
@@ -46505,9 +46729,40 @@ var init_ai = __esm(() => {
   };
 });
 
+// src/core/ai/model-history.ts
+function addRecentModelId(recentModelIds, modelId) {
+  const nextRecentModelIds = [];
+  for (const id of [modelId, ...recentModelIds]) {
+    if (nextRecentModelIds.includes(id))
+      continue;
+    nextRecentModelIds.push(id);
+    if (nextRecentModelIds.length === MAX_RECENT_MODELS)
+      break;
+  }
+  return nextRecentModelIds;
+}
+function getRecentModels(availableModels, recentModelIds) {
+  const modelsById = new Map(availableModels.map((model) => [model.id, model]));
+  const seen = new Set;
+  const recentModels = [];
+  for (const id of recentModelIds) {
+    const model = modelsById.get(id);
+    if (!model || seen.has(id))
+      continue;
+    seen.add(id);
+    recentModels.push(model);
+    if (recentModels.length === MAX_RECENT_MODELS)
+      break;
+  }
+  return recentModels;
+}
+var MAX_RECENT_MODELS = 5;
+var init_model_history = () => {};
+
 // src/core/ai/index.ts
 var init_ai2 = __esm(() => {
   init_ai();
+  init_model_history();
   init_models();
   init_utils();
 });
@@ -46545,7 +46800,9 @@ async function generateSessionName(opts) {
       maxTokens: 50,
       temperature: 0.7,
       authConfig,
-      abortSignal
+      abortSignal,
+      sessionId: opts.sessionId,
+      operation: "apex.session.name"
     });
     if (!result?.name)
       return null;
@@ -46672,7 +46929,11 @@ function toReference(stored) {
     ref.customHeaderKeys = Object.keys(stored.tokens.customHeaders);
   }
   if (stored.additionalFields) {
-    const keys = Object.keys(stored.additionalFields);
+    const authMethod = stored.additionalFields.authMethod;
+    const recognized = isMobileOtpAuthMethod(authMethod);
+    if (recognized)
+      ref.authMethod = authMethod;
+    const keys = Object.keys(stored.additionalFields).filter((key) => !(key === "authMethod" && recognized));
     if (keys.length > 0)
       ref.additionalFieldKeys = keys;
   }
@@ -46681,6 +46942,9 @@ function toReference(stored) {
     ref.context = ctx;
   return ref;
 }
+function isMobileOtpAuthMethod(value) {
+  return value === "sms-passwordless" || value === "sms-mfa";
+}
 
 class CredentialManager {
   store = new Map;
@@ -46787,6 +47051,9 @@ class CredentialManager {
       if (ref.additionalFieldKeys?.length) {
         parts.push(`  Additional secret fields: ${ref.additionalFieldKeys.join(", ")}`);
       }
+      if (ref.authMethod) {
+        parts.push(`  Authentication method: ${ref.authMethod}`);
+      }
       if (ref.context)
         parts.push(`  Context: ${ref.context}`);
       return parts.join(`
@@ -47341,7 +47608,7 @@ async function create2(input) {
   if (normalizedConfig?.headers !== undefined) {
     snapshotHeaders = { ...normalizedConfig.headers };
   } else {
-    const { config: appConfig } = await import("./index-ghwf5z3v.js");
+    const { config: appConfig } = await import("./index-p01t9n89.js");
     const cfg = await appConfig.get();
     snapshotHeaders = cfg.defaultHeaders ? { ...cfg.defaultHeaders } : { ...DEFAULT_HEADER_RECORD };
   }
@@ -47377,7 +47644,8 @@ async function create2(input) {
       targets: input.targets,
       userMessage: input.userMessage,
       model: input.model,
-      authConfig: input.authConfig
+      authConfig: input.authConfig,
+      sessionId: result.id
     }).then((aiName) => {
       if (aiName) {
         result.name = aiName;
@@ -47689,6 +47957,7 @@ var init_session = __esm(() => {
     prompt: zod_default.string().optional(),
     taskDriven: zod_default.boolean().optional(),
     requirePlan: zod_default.boolean().optional(),
+    disableSubagents: zod_default.boolean().optional(),
     promptInjectionLibrarySource: zod_default.string().optional()
   });
   SessionInfoObject = zod_default.object({
@@ -47906,6 +48175,11 @@ class Logger {
         }
       }
     }
+    const correlation = getActiveTraceCorrelation();
+    if (correlation) {
+      record.trace_id = correlation.traceId;
+      record.span_id = correlation.spanId;
+    }
     return safeStringify(record);
   }
   formatPretty(ts, level, msg, fields) {
@@ -47932,6 +48206,7 @@ function createLogger(scope) {
 var SEVERITY, VALID_LEVELS, COLORS, RESET = "\x1B[0m", DIM = "\x1B[2m", stderrSink = (line) => process.stderr.write(`${line}
 `), sink, logger;
 var init_structured = __esm(() => {
+  init_observability();
   init_logger();
   SEVERITY = {
     DEBUG: 10,
@@ -49284,14 +49559,22 @@ async function summarizeConversation(messages, opts, model) {
       content: `Summarize this conversation to pass to another agent. This was the original system prompt (truncated for safety): ${systemSnippet}`
     }
   ];
-  const { text: summary, usage: summaryUsage } = await generateText({
+  const {
+    text: summary,
+    usage: summaryUsage,
+    providerMetadata: summaryProviderMetadata
+  } = await generateText({
     model,
     system: `You are a helpful assistant that summarizes conversations to pass to another agent. Review the conversation and system prompt at the end provided by the user.`,
     messages: summarizedMessages,
-    abortSignal: opts.abortSignal
+    abortSignal: opts.abortSignal,
+    experimental_telemetry: createAiTelemetrySettings({
+      operation: "apex.context.summarize",
+      sessionId: opts.sessionId
+    })
   });
   if (opts.onStepFinish && summaryUsage) {
-    opts.onStepFinish({
+    await opts.onStepFinish({
       text: "",
       reasoning: undefined,
       reasoningDetails: [],
@@ -49303,16 +49586,18 @@ async function summarizeConversation(messages, opts, model) {
       usage: {
         inputTokens: summaryUsage.inputTokens ?? 0,
         outputTokens: summaryUsage.outputTokens ?? 0,
-        totalTokens: summaryUsage.totalTokens ?? 0
+        totalTokens: summaryUsage.totalTokens ?? 0,
+        ...summaryUsage.inputTokenDetails ? { inputTokenDetails: summaryUsage.inputTokenDetails } : {}
       },
       warnings: [],
       request: {},
       response: {
         id: "summarization",
         timestamp: new Date,
-        modelId: ""
+        modelId: "",
+        messages
       },
-      providerMetadata: undefined,
+      providerMetadata: summaryProviderMetadata,
       stepType: "initial",
       isContinued: false
     });
@@ -49374,22 +49659,25 @@ function createSummarizationStream(messages, opts, model) {
       yield chunk;
     }
   }();
+  const resumedForFields = resumedStreamPromise.catch(() => {
+    return;
+  });
   return {
     fullStream: wrappedFullStream,
-    text: resumedStreamPromise.then((s) => s.text),
-    content: resumedStreamPromise.then((s) => s.content),
-    reasoning: resumedStreamPromise.then((s) => s.reasoning),
-    reasoningText: resumedStreamPromise.then((s) => s.reasoningText),
-    toolCalls: resumedStreamPromise.then((s) => s.toolCalls),
-    toolResults: resumedStreamPromise.then((s) => s.toolResults),
-    usage: resumedStreamPromise.then((s) => s.usage),
-    finishReason: resumedStreamPromise.then((s) => s.finishReason),
-    warnings: resumedStreamPromise.then((s) => s.warnings),
-    response: resumedStreamPromise.then((s) => s.response),
-    files: resumedStreamPromise.then((s) => s.files),
-    sources: resumedStreamPromise.then((s) => s.sources),
-    staticToolCalls: resumedStreamPromise.then((s) => s.staticToolCalls),
-    dynamicToolCalls: resumedStreamPromise.then((s) => s.dynamicToolCalls),
+    text: resumedForFields.then((s) => s?.text),
+    content: resumedForFields.then((s) => s?.content),
+    reasoning: resumedForFields.then((s) => s?.reasoning),
+    reasoningText: resumedForFields.then((s) => s?.reasoningText),
+    toolCalls: resumedForFields.then((s) => s?.toolCalls),
+    toolResults: resumedForFields.then((s) => s?.toolResults),
+    usage: resumedForFields.then((s) => s?.usage),
+    finishReason: resumedForFields.then((s) => s?.finishReason),
+    warnings: resumedForFields.then((s) => s?.warnings),
+    response: resumedForFields.then((s) => s?.response),
+    files: resumedForFields.then((s) => s?.files),
+    sources: resumedForFields.then((s) => s?.sources),
+    staticToolCalls: resumedForFields.then((s) => s?.staticToolCalls),
+    dynamicToolCalls: resumedForFields.then((s) => s?.dynamicToolCalls),
     pipeTextStreamToResponse: async (response, init) => {
       const stream = await resumedStreamPromise;
       return stream.pipeTextStreamToResponse(response, init);
@@ -49416,6 +49704,7 @@ var init_utils = __esm(() => {
   init_auth();
   init_config();
   init_structured();
+  init_observability();
   init_lazyLogger();
   init_ai();
   init_contextManagement();
@@ -49426,4 +49715,4 @@ var init_utils = __esm(() => {
   STREAMING_FETCH_TIMEOUT_MS = 35 * 60 * 1000;
 });
 
-export { stepCountIs, hasToolCall, init_dist4 as init_dist, AVAILABLE_MODELS, init_models, require_tslib, scopedLogger, init_lazyLogger, buildAuthConfig, init_utils, init_ai2 as init_ai, generateRandomName, generateSessionName, init_name, CredentialManager, init_credentials, schema, descending, newSessionId, newMessageId, newPartId, init_id, RateLimiter, init_rateLimiter, NotFoundError, write2 as write, createDir, writeRaw, read2 as read, update, list, init_storage, ToolsetStateSchema, init_toolset, create2 as create, list2 as list1, normalizeMessages, sessions, init_session, writeErrorLog, routeLogsToErrorFile, init_logger, createLogger, logger, init_structured, getApexTracer, withSubagentSessionBaggage, init_observability, DEFAULT_OPENAI_REASONING_EFFORT, modelSupportsThinking, modelSupportsOpenAIReasoning, getOpenAIReasoningEfforts, streamResponse, generateObjectResponse, init_ai as init_ai1 };
+export { stepCountIs, hasToolCall, init_dist4 as init_dist, schema, descending, newSessionId, newMessageId, newPartId, init_id, registerActiveRootSpan, unregisterActiveRootSpan, endAllActiveRootSpans, init_active_root_spans, getApexTracer, shouldRecordAiPayloads, withSubagentSessionBaggage, getActiveTraceCorrelation, init_observability, addRecentModelId, getRecentModels, init_model_history, AVAILABLE_MODELS, init_models, require_tslib, scopedLogger, init_lazyLogger, buildAuthConfig, init_utils, init_ai2 as init_ai, generateRandomName, generateSessionName, init_name, CredentialManager, init_credentials, RateLimiter, init_rateLimiter, NotFoundError, write2 as write, createDir, writeRaw, read2 as read, update, list, init_storage, ToolsetStateSchema, init_toolset, create2 as create, list2 as list1, getResumeMessages, normalizeMessages, sessions, init_session, writeErrorLog, routeLogsToErrorFile, init_logger, createLogger, logger, init_structured, DEFAULT_OPENAI_REASONING_EFFORT, getContextWindow, modelSupportsThinking, modelSupportsOpenAIReasoning, getOpenAIReasoningEfforts, streamResponse, generateObjectResponse, init_ai as init_ai1 };