@lota-sdk/core 0.4.20 → 0.4.22

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@lota-sdk/core",
-  "version": "0.4.20",
-  "type": "module",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "version": "0.4.22",
   "files": [
     "src",
     "infrastructure/schema"
   ],
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
   "exports": {
     ".": {
       "bun": "./src/index.ts",
@@ -15,6 +15,10 @@
       "types": "./src/index.ts"
     }
   },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
   "scripts": {
     "lint": "bunx oxlint --fix -c ../oxlint.config.ts src",
     "format": "bunx oxfmt src",
@@ -22,23 +26,19 @@
     "test:unit": "bun test --max-concurrency=1 ../tests/unit/core",
     "test:coverage": "bun test --coverage ../tests/unit/core"
   },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
   "dependencies": {
-    "@ai-sdk/devtools": "^0.0.15",
-    "@ai-sdk/openai": "^3.0.53",
+    "@ai-sdk/devtools": "^0.0.16",
+    "@ai-sdk/openai": "^3.0.54",
     "@chat-adapter/slack": "^4.26.0",
     "@chat-adapter/state-ioredis": "^4.26.0",
-    "@lota-sdk/shared": "0.4.20",
-    "@mendable/firecrawl-js": "^4.18.3",
+    "@lota-sdk/shared": "0.4.22",
+    "@mendable/firecrawl-js": "^4.20.0",
     "@surrealdb/node": "^3.0.3",
-    "ai": "^6.0.168",
-    "bullmq": "^5.74.2",
+    "ai": "^6.0.170",
+    "bullmq": "^5.76.4",
     "chat": "^4.26.0",
-    "effect": "^4.0.0-beta.52",
-    "hono": "^4.12.14",
+    "effect": "^4.0.0-beta.59",
+    "hono": "^4.12.15",
     "ioredis": "5.9.3",
     "mammoth": "^1.12.0",
     "pdf-parse": "^2.4.5",

package/src/ai-gateway/ai-gateway.ts

@@ -721,6 +721,16 @@ function isReasoningEnabled(params: AiGatewayCallOptions): boolean {
   return typeof openaiOptions.reasoningEffort === 'string' && openaiOptions.reasoningEffort !== 'none'
 }
 
+function hasFunctionTools(params: AiGatewayCallOptions): boolean {
+  return Array.isArray(params.tools) && params.tools.some((tool) => isRecord(tool) && tool.type === 'function')
+}
+
+function isGpt55Model(modelId: string): boolean {
+  const normalized = modelId.trim().toLowerCase()
+  const modelName = normalized.split('/').at(-1) ?? normalized
+  return modelName === 'gpt-5.5' || modelName.startsWith('gpt-5.5-')
+}
+
 function isOpenRouterModel(modelId: string): boolean {
   return modelId.trim().toLowerCase().startsWith('openrouter/')
 }
@@ -882,12 +892,91 @@ function addAiGatewayReasoningRawChunks(
   return { ...params, includeRawChunks: true }
 }
 
+const JSON_SCHEMA_PROPERTY_MAP_KEYS = new Set([
+  '$defs',
+  'definitions',
+  'dependentSchemas',
+  'patternProperties',
+  'properties',
+])
+
+function stripJsonSchemaFormatKeywords(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map((item) => stripJsonSchemaFormatKeywords(item))
+  }
+
+  if (!isRecord(value)) {
+    return value
+  }
+
+  let changed = false
+  const nextValue: Record<string, unknown> = {}
+
+  for (const [key, child] of Object.entries(value)) {
+    if (key === 'format') {
+      changed = true
+      continue
+    }
+
+    if (JSON_SCHEMA_PROPERTY_MAP_KEYS.has(key) && isRecord(child)) {
+      let mapChanged = false
+      const nextMap: Record<string, unknown> = {}
+      for (const [propertyName, propertySchema] of Object.entries(child)) {
+        const nextPropertySchema = stripJsonSchemaFormatKeywords(propertySchema)
+        mapChanged ||= nextPropertySchema !== propertySchema
+        nextMap[propertyName] = nextPropertySchema
+      }
+      changed ||= mapChanged
+      nextValue[key] = mapChanged ? nextMap : child
+      continue
+    }
+
+    const nextChild = stripJsonSchemaFormatKeywords(child)
+    changed ||= nextChild !== child
+    nextValue[key] = nextChild
+  }
+
+  return changed ? nextValue : value
+}
+
+export function normalizeAiGatewayJsonSchemas(params: AiGatewayCallOptions): AiGatewayCallOptions {
+  let nextParams = params
+
+  if (params.responseFormat?.type === 'json' && params.responseFormat.schema) {
+    const nextSchema = stripJsonSchemaFormatKeywords(params.responseFormat.schema)
+    if (nextSchema !== params.responseFormat.schema) {
+      nextParams = { ...nextParams, responseFormat: { ...params.responseFormat, schema: nextSchema } }
+    }
+  }
+
+  const sourceTools = nextParams.tools
+  if (!Array.isArray(sourceTools)) {
+    return nextParams
+  }
+
+  const nextTools = sourceTools.map((tool) => {
+    if (!isRecord(tool) || tool.type !== 'function') {
+      return tool
+    }
+
+    const inputSchema = (tool as { inputSchema: unknown }).inputSchema
+    const nextInputSchema = stripJsonSchemaFormatKeywords(inputSchema)
+    return { ...tool, inputSchema: nextInputSchema }
+  })
+
+  return { ...nextParams, tools: nextTools as AiGatewayCallOptions['tools'] }
+}
+
 function resolveProviderModel(
   provider: ReturnType<typeof createOpenAI>,
   modelId: string,
   providerId: string,
 ): AiGatewayLanguageModel {
-  return providerId === OPENAI_CHAT_PROVIDER_ID ? provider.chat(modelId) : provider(modelId)
+  if (providerId !== OPENAI_CHAT_PROVIDER_ID) {
+    return provider(modelId)
+  }
+
+  return provider.chat(modelId)
 }
 
 export type AiGatewayDeps = {
@@ -927,7 +1016,12 @@ function createAiGatewayLanguageModelMiddleware(
     transformParams: ({ params, type }) =>
       Promise.resolve(
         withDefaultAiGatewayCacheHeaders(
-          addAiGatewayReasoningRawChunks(normalizeAiGatewayChatProviderOptions(params, modelId), type),
+          addAiGatewayReasoningRawChunks(
+            normalizeAiGatewayJsonSchemas(
+              providerId === OPENAI_CHAT_PROVIDER_ID ? normalizeAiGatewayChatProviderOptions(params, modelId) : params,
+            ),
+            type,
+          ),
         ),
       ),
     wrapGenerate: ({ params }) => {
@@ -972,9 +1066,38 @@ function createAiGatewayLanguageModelMiddleware(
 
 export function normalizeAiGatewayChatProviderOptions(
   params: AiGatewayCallOptions,
-  _modelId?: string,
+  modelId?: string,
 ): AiGatewayCallOptions {
-  return params
+  if (!modelId || !isGpt55Model(modelId) || !hasFunctionTools(params)) {
+    return params
+  }
+
+  if (!isRecord(params.providerOptions) || !isRecord(params.providerOptions.openai)) {
+    return params
+  }
+
+  const openaiOptions = { ...params.providerOptions.openai }
+  const strippedReasoningOptions =
+    'forceReasoning' in openaiOptions || 'reasoningEffort' in openaiOptions || 'reasoningSummary' in openaiOptions
+  if (!strippedReasoningOptions) {
+    return params
+  }
+
+  delete openaiOptions.forceReasoning
+  delete openaiOptions.reasoningEffort
+  delete openaiOptions.reasoningSummary
+
+  const providerOptions = { ...params.providerOptions }
+  delete providerOptions.openai
+  const nextProviderOptions =
+    Object.keys(openaiOptions).length === 0 ? providerOptions : { ...providerOptions, openai: openaiOptions }
+
+  if (Object.keys(nextProviderOptions).length === 0) {
+    const { providerOptions: _providerOptions, ...nextParams } = params
+    return nextParams
+  }
+
+  return { ...params, providerOptions: nextProviderOptions as AiGatewayCallOptions['providerOptions'] }
 }
 
 function withAiGatewayDevTools<TModel extends AiGatewayLanguageModel>(model: TModel): TModel {

package/src/ai-gateway/index.ts

@@ -14,6 +14,7 @@ export {
   injectAiGatewayChatReasoningContent,
   injectAiGatewayChatReasoningStream,
   normalizeAiGatewayChatProviderOptions,
+  normalizeAiGatewayJsonSchemas,
   normalizeAiGatewayUrl,
 } from './ai-gateway'
 export type { AiGatewayDeps, AiGatewayModels, RuntimeBridge } from './ai-gateway'

package/src/runtime/runtime-services.ts

@@ -82,15 +82,15 @@ type PromisifiedService<T> = {
 
 type HostSvc<T extends { readonly Service: object }> = PromisifiedService<T['Service']>
 
-export type PromisifiedThreadService = HostSvc<typeof ThreadServiceTag>
-export type PromisifiedDocumentChunkService = HostSvc<typeof DocumentChunkServiceTag>
+type PromisifiedThreadService = HostSvc<typeof ThreadServiceTag>
+type PromisifiedDocumentChunkService = HostSvc<typeof DocumentChunkServiceTag>
 
-export type ArchiveSdkThread = (
+type ArchiveSdkThread = (
   threadId: Parameters<Svc<typeof ThreadServiceTag>['updateStatus']>[0],
   status?: 'archived',
 ) => ReturnType<Svc<typeof ThreadServiceTag>['updateStatus']>
 
-export type UnarchiveSdkThread = (
+type UnarchiveSdkThread = (
   threadId: Parameters<Svc<typeof ThreadServiceTag>['updateStatus']>[0],
   status?: 'active',
 ) => ReturnType<Svc<typeof ThreadServiceTag>['updateStatus']>

package/src/runtime/thread-plan-turn.ts

@@ -5,7 +5,7 @@ import { nowEpochMillis } from '../utils/date-time'
 import { buildCompletionCheckStructuredOutputHints } from './agent-runtime-policy'
 import { mergeInstructionSections } from './instruction-sections'
 
-export interface PlanTurnUpstreamHandoff {
+interface PlanTurnUpstreamHandoff {
   nodeId: string
   label: string
   ownerRef: string

package/src/workers/utils/thread-message-query.ts

@@ -16,7 +16,7 @@ import type { LotaRuntimeBackgroundCursor } from '../../runtime/runtime-extensio
 import type { SocialChatHistoryMessage } from '../../services/social-chat-history.service'
 import { unsafeDateFrom } from '../../utils/date-time'
 
-export interface ThreadDigestMessage {
+interface ThreadDigestMessage {
   source: 'thread'
   sourceId: string
   role: 'system' | 'user' | 'assistant'
@@ -25,7 +25,7 @@ export interface ThreadDigestMessage {
   cursor: LotaRuntimeBackgroundCursor
 }
 
-export type SocialDigestMessage = Pick<
+type SocialDigestMessage = Pick<
   SocialChatHistoryMessage,
   'source' | 'sourceId' | 'role' | 'parts' | 'metadata' | 'cursor'
 >