@capekai/core 1.0.5 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capekai/core",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Bun-native composable agent runtime and framework for Capek.",
   "license": "MIT",
   "repository": {
@@ -78,7 +78,7 @@
     "@ai-sdk/deepseek": "^2.0.35",
     "@ai-sdk/openai": "^3.0.84",
     "@capekai/tool": "^1.0.3",
-    "@capekai/types": "^1.0.2",
+    "@capekai/types": "^1.0.3",
     "@openrouter/ai-sdk-provider": "^2.3.3",
     "@zip.js/zip.js": "^2.7.60",
     "ai": "^6.0.116",

package/src/adapters/ai-sdk.ts

@@ -8,6 +8,7 @@ import {
   type Tool,
 } from 'ai';
 import { getModelWithMetadata } from '../core/model-utils';
+import { openAiModelOmitsTemperature } from '../core/provider-utils';
 import type { ModelFactoryResult } from '../providers/types';
 
 export interface TextModelRequest {
@@ -21,7 +22,7 @@ export interface TextModelRequest {
 }
 
 export async function runTextModel(request: TextModelRequest): Promise<string> {
-  const { model, omitMaxOutputTokens, providerOptions, useProviderInstructions } = await getModelWithMetadata({
+  const { model, omitMaxOutputTokens, omitTemperature, providerOptions, useProviderInstructions } = await getModelWithMetadata({
     modelId: request.modelId,
     providerId: request.providerId,
     systemPrompt: request.systemPrompt,
@@ -34,7 +35,7 @@ export async function runTextModel(request: TextModelRequest): Promise<string> {
     ...(omitMaxOutputTokens || request.maxOutputTokens === undefined
       ? {}
       : { maxOutputTokens: request.maxOutputTokens }),
-    temperature: request.temperature,
+    ...(omitTemperature ? {} : { temperature: request.temperature }),
     providerOptions: providerOptions as Parameters<typeof streamText>[0]['providerOptions'],
   });
   return stream.text;
@@ -57,6 +58,7 @@ export function createOpenAiResponsesModel(request: OpenAiResponsesModelRequest)
     model: openai.responses(request.modelId) as unknown as LanguageModel,
     useProviderInstructions: true,
     omitMaxOutputTokens: true,
+    omitTemperature: openAiModelOmitsTemperature(request.modelId),
     providerOptions: {
       openai: {
         instructions: request.systemPrompt || 'You are a helpful assistant.',

package/src/core/agent.ts

@@ -121,6 +121,7 @@ export async function* streamChat(options: ChatOptions): AsyncGenerator<MessageE
     broadcastFn: options.broadcastFn,
     additionalPaths: effectiveAdditionalPaths,
     agentId: preconfig.id,
+    workspaceRootId: session?.workspaceRootId ?? undefined,
   });
 
   const selfDelegationAvailable = Boolean(aiTools.task)
@@ -140,7 +141,7 @@ export async function* streamChat(options: ChatOptions): AsyncGenerator<MessageE
     selfDelegationAvailable,
   });
 
-  const { model, useProviderInstructions, omitMaxOutputTokens, providerOptions: baseProviderOptions } =
+  const { model, useProviderInstructions, omitMaxOutputTokens, omitTemperature, providerOptions: baseProviderOptions } =
     await getModelWithMetadata({
       modelId: resolvedModelId,
       providerId,
@@ -198,7 +199,7 @@ export async function* streamChat(options: ChatOptions): AsyncGenerator<MessageE
     tools: aiTools,
     maxOutputTokens: omitMaxOutputTokens ? undefined : getMaxOutputTokens(resolvedModelId),
     providerOptions: streamConfig.providerOptions as Parameters<typeof streamText>[0]['providerOptions'],
-    temperature: streamConfig.temperature,
+    ...(omitTemperature ? {} : { temperature: streamConfig.temperature }),
     stopWhen: stepCountIs(streamConfig.maxSteps),
     abortSignal: abortController.signal,
     experimental_onStepStart,

package/src/core/build-tools.ts

@@ -33,6 +33,7 @@ export interface BuildToolsOptions {
   broadcastFn?: AskBroadcastFn;
   additionalPaths?: string[];
   agentId?: string | null;
+  workspaceRootId?: string;
 }
 
 export async function buildAiSdkTools(
@@ -53,6 +54,7 @@ export async function buildAiSdkTools(
     broadcastFn,
     additionalPaths,
     agentId,
+    workspaceRootId,
   } = options;
 
   // Resolve root session ID by walking up the parent chain
@@ -92,6 +94,7 @@ export async function buildAiSdkTools(
     modelId,
     providerId,
     additionalPaths,
+    workspaceRootId,
   });
   const tools: ToolMap = { ...externalTools };
 

package/src/core/chat-handler.ts

@@ -6,6 +6,7 @@ import {
   isDefaultSessionTitle,
   isSandboxActive,
   emitTerminal,
+  resolveSessionWorkspace,
 } from '../runtime/host-dependencies';
 import { getDefaultPreconfig, getPreconfigOrAgent } from '../context';
 import {
@@ -552,8 +553,15 @@ export async function handleChat<Origin>(
   }
 
   const workspace = session.workspaceId ? await getWorkspace(session.workspaceId) : null;
-  const workspacePath = workspace?.path;
-  const additionalPaths = workspace?.additionalPaths;
+  const workspaceContext = await resolveSessionWorkspace({
+    sessionId,
+    workspaceId: session.workspaceId || undefined,
+    workspaceRootId: session.workspaceRootId ?? undefined,
+    workspacePath: workspace?.path,
+    additionalPaths: workspace?.additionalPaths,
+  });
+  const workspacePath = workspaceContext.workspacePath;
+  const additionalPaths = workspaceContext.additionalPaths;
 
   const preconfig = session.preconfigId
     ? await getPreconfigOrAgent(session.preconfigId)
@@ -810,8 +818,15 @@ export async function handleSessionEditMessage<Origin>(
     });
 
     const workspace = session.workspaceId ? await getWorkspace(session.workspaceId) : null;
-    const workspacePath = workspace?.path;
-    const additionalPaths = workspace?.additionalPaths;
+    const workspaceContext = await resolveSessionWorkspace({
+      sessionId: msg.sessionId,
+      workspaceId: session.workspaceId || undefined,
+      workspaceRootId: session.workspaceRootId ?? undefined,
+      workspacePath: workspace?.path,
+      additionalPaths: workspace?.additionalPaths,
+    });
+    const workspacePath = workspaceContext.workspacePath;
+    const additionalPaths = workspaceContext.additionalPaths;
 
     const preconfig = session.preconfigId
       ? await getPreconfigOrAgent(session.preconfigId)

package/src/core/model-utils.ts

@@ -1,6 +1,6 @@
 import { type LanguageModel } from 'ai';
 import { createOpenAI } from '@ai-sdk/openai';
-import { findProviderFromModel, parseModelSpecifier } from './provider-utils';
+import { findProviderFromModel, openAiModelOmitsTemperature, parseModelSpecifier } from './provider-utils';
 import { findModel, getApiKeyForProvider, getLLMBaseUrl, getModelsConfig } from '../configuration/runtime';
 import { createModelForProvider, getProvider } from '../providers/registry';
 import { isSandboxActive } from '../runtime/host-dependencies';
@@ -9,6 +9,7 @@ export interface ModelWithMetadata {
   model: LanguageModel;
   useProviderInstructions?: boolean;
   omitMaxOutputTokens?: boolean;
+  omitTemperature?: boolean;
   providerOptions?: Record<string, Record<string, unknown>>;
 }
 
@@ -46,6 +47,7 @@ export async function getModelWithMetadata(
       model: result.model,
       useProviderInstructions: result.useProviderInstructions,
       omitMaxOutputTokens: result.omitMaxOutputTokens,
+      omitTemperature: result.omitTemperature,
       providerOptions: result.providerOptions,
     };
   }
@@ -77,6 +79,7 @@ export async function getModelWithMetadata(
       model: result.model,
       useProviderInstructions: result.useProviderInstructions,
       omitMaxOutputTokens: result.omitMaxOutputTokens,
+      omitTemperature: result.omitTemperature,
       providerOptions: result.providerOptions,
     };
   }
@@ -132,6 +135,7 @@ export async function getModelWithMetadata(
       });
       return {
         model: openai.responses(model) as unknown as LanguageModel,
+        omitTemperature: openAiModelOmitsTemperature(model),
         providerOptions: {
           openai: {
             promptCacheKey: options.sessionId,

package/src/core/provider-utils.ts

@@ -19,6 +19,10 @@ const PROVIDER_PREFIXES: Array<{ test: (m: string) => boolean; provider: string
   { test: (m) => m.startsWith('deepseek-'), provider: 'deepseek' },
 ];
 
+export function openAiModelOmitsTemperature(modelId: string): boolean {
+  return modelId.startsWith('gpt-6');
+}
+
 export interface ParsedModelSpecifier {
   modelId: string;
   providerId?: string;

package/src/core/tool-builders/external-tools.ts

@@ -19,7 +19,7 @@ import {
 } from '../../runtime/domain-tool-source';
 import { isToolAllowedInContext, type ToolExecutionScope } from '../tool-capabilities';
 import type { ToolMap } from './types';
-import type { BroadcastFn } from '../../runtime/host-dependencies';
+import { resolveToolDefinition, type BroadcastFn } from '../../runtime/host-dependencies';
 import {
   capekToolOutputToAiSdk,
   createCapekToolOutputEnvelope,
@@ -39,6 +39,7 @@ export interface ExternalToolsOptions {
   modelId?: string;
   providerId?: string;
   additionalPaths?: string[];
+  workspaceRootId?: string;
 }
 
 export async function buildExternalTools(options: ExternalToolsOptions): Promise<ToolMap> {
@@ -56,6 +57,7 @@ export async function buildExternalTools(options: ExternalToolsOptions): Promise
     modelId,
     providerId,
     additionalPaths,
+    workspaceRootId,
   } = options;
 
   const tools: ToolMap = {};
@@ -83,7 +85,14 @@ export async function buildExternalTools(options: ExternalToolsOptions): Promise
     const loadedTool = await getTool(name);
     if (!loadedTool) continue;
 
-    const { definition } = loadedTool;
+    const definition = await resolveToolDefinition({
+      sessionId,
+      workspaceId,
+      workspaceRootId,
+      workspacePath,
+      definition: loadedTool.definition,
+    });
+    if (!definition) continue;
 
     if (!isToolAllowedInContext(definition.capabilities, executionScopes)) {
       continue;

package/src/internal/hosts.ts

@@ -22,7 +22,9 @@ export {
   type PermissionRequestStatus,
   type RuntimeHost,
   type SandboxBindings,
+  type SessionWorkspaceContext,
   type TitleHost,
+  type ToolPolicyHost,
   type WorkspaceCapabilityBindings,
 } from '../runtime/host';
 export { createStandaloneHost } from '../runtime/standalone-host';

package/src/providers/types.ts

@@ -12,6 +12,7 @@ export interface ModelFactoryResult {
   model: LanguageModel;
   useProviderInstructions?: boolean;
   omitMaxOutputTokens?: boolean;
+  omitTemperature?: boolean;
   providerOptions?: Record<string, Record<string, unknown>>;
 }
 

package/src/runtime/host-dependencies.ts

@@ -1,5 +1,6 @@
 import type { Session } from '@capekai/types';
-import { getRuntimeHost } from './host';
+import type { ToolDefinition } from '@capekai/tool';
+import { getOptionalRuntimeHost, getRuntimeHost } from './host';
 import type { RuntimeAudience, RuntimeDelivery, RuntimeEvent } from './events';
 
 type HostRuntimeAudience = Exclude<RuntimeAudience, { scope: 'origin' }>;
@@ -66,6 +67,38 @@ export const generateSessionTitle = (...args: Parameters<ReturnType<typeof getRu
   getRuntimeHost().titles.generateSessionTitle(...args);
 export const getToolWorkspaceHost = (...args: Parameters<ReturnType<typeof getRuntimeHost>['workspace']['createToolWorkspaceHost']>) =>
   getRuntimeHost().workspace.createToolWorkspaceHost(...args);
+
+export async function resolveSessionWorkspace(options: {
+  sessionId: string;
+  workspaceId?: string;
+  workspaceRootId?: string;
+  workspacePath?: string;
+  additionalPaths?: string[];
+}): Promise<{ workspacePath?: string; additionalPaths?: string[] }> {
+  const resolver = getRuntimeHost().workspace.resolveSessionWorkspace;
+  if (resolver) {
+    return await resolver(options);
+  }
+  if (options.workspaceRootId) {
+    throw new Error('Session workspace root requires a host resolver');
+  }
+  return {
+    workspacePath: options.workspacePath,
+    additionalPaths: options.additionalPaths,
+  };
+}
+
+export async function resolveToolDefinition(options: {
+  sessionId: string;
+  workspaceId?: string;
+  workspaceRootId?: string;
+  workspacePath?: string;
+  definition: ToolDefinition;
+}): Promise<ToolDefinition | null> {
+  const resolver = getOptionalRuntimeHost()?.toolPolicy?.resolveDefinition;
+  return resolver ? await resolver(options) : options.definition;
+}
+
 export const isSandboxActive = (): boolean => getRuntimeHost().sandbox.isSandboxActive();
 
 export type { RuntimeEventSink, RuntimeEventSink as BroadcastFn } from './events';

package/src/runtime/host.ts

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import type { HostLayout } from './host-layout';
-import type { Ask } from '@capekai/tool';
+import type { Ask, ToolDefinition } from '@capekai/tool';
 import type {
   AskRequestMessage, AskTimedOutMessage, AutoApproveSeverity, MessageWithParts, Session,
 } from '@capekai/types';
@@ -82,7 +82,19 @@ export interface TitleHost {
   generateSessionTitle(messages: MessageWithParts[]): Promise<string | null>;
 }
 
+export interface SessionWorkspaceContext {
+  workspacePath?: string;
+  additionalPaths?: string[];
+}
+
 export interface WorkspaceCapabilityBindings {
+  resolveSessionWorkspace?(options: {
+    sessionId: string;
+    workspaceId?: string;
+    workspaceRootId?: string;
+    workspacePath?: string;
+    additionalPaths?: string[];
+  }): SessionWorkspaceContext | Promise<SessionWorkspaceContext>;
   createToolWorkspaceHost(options: {
     workspaceId?: string;
     workspacePath?: string;
@@ -91,6 +103,16 @@ export interface WorkspaceCapabilityBindings {
   }): WorkspaceCapabilityHost;
 }
 
+export interface ToolPolicyHost {
+  resolveDefinition?(options: {
+    sessionId: string;
+    workspaceId?: string;
+    workspaceRootId?: string;
+    workspacePath?: string;
+    definition: ToolDefinition;
+  }): ToolDefinition | null | Promise<ToolDefinition | null>;
+}
+
 export interface SandboxBindings {
   isSandboxActive(): boolean;
 }
@@ -100,6 +122,7 @@ export interface RuntimeHost {
   delivery: DeliveryHost;
   titles: TitleHost;
   workspace: WorkspaceCapabilityBindings;
+  toolPolicy?: ToolPolicyHost;
   sandbox: SandboxBindings;
   /** Host-supplied filesystem layout policy. */
   layout?: HostLayout;
@@ -122,8 +145,12 @@ export function withRuntimeHost<T>(value: RuntimeHost, callback: () => T): T {
   return scopedHost.run(value, callback);
 }
 
+export function getOptionalRuntimeHost(): RuntimeHost | null {
+  return scopedHost.getStore() ?? host;
+}
+
 export function getRuntimeHost(): RuntimeHost {
-  const active = scopedHost.getStore() ?? host;
+  const active = getOptionalRuntimeHost();
   if (!active) throw new Error('Runtime host has not been configured');
   return active;
 }

package/src/subagent/child-session.ts

@@ -5,6 +5,7 @@ import {
   emitTerminal,
   emitToAskTargets,
   emitToController,
+  resolveSessionWorkspace,
 } from '../runtime/host-dependencies';
 import { getLLMSubagentMaxSteps } from '../configuration/runtime';
 import {
@@ -59,9 +60,21 @@ export async function executeChildSession(options: {
     streamChat = streamChatWithRetry,
   } = options;
 
-  // Resolve additionalPaths from workspace
-  const workspace = workspaceId ? await getWorkspace(workspaceId) : null;
-  const additionalPaths = workspace?.additionalPaths;
+  // Re-resolve the child session's host-owned root. Async child execution may
+  // enter after the parent context was assembled, so the persisted child
+  // binding is authoritative.
+  const childSession = await getSession(childSessionId);
+  const effectiveWorkspaceId = workspaceId ?? childSession?.workspaceId ?? undefined;
+  const workspace = effectiveWorkspaceId ? await getWorkspace(effectiveWorkspaceId) : null;
+  const workspaceContext = await resolveSessionWorkspace({
+    sessionId: childSessionId,
+    workspaceId: effectiveWorkspaceId,
+    workspaceRootId: childSession?.workspaceRootId ?? undefined,
+    workspacePath: workspacePath ?? workspace?.path,
+    additionalPaths: workspace?.additionalPaths,
+  });
+  const effectiveWorkspacePath = workspaceContext.workspacePath;
+  const additionalPaths = workspaceContext.additionalPaths;
 
   let messages: MessageWithParts[];
 
@@ -172,8 +185,8 @@ export async function executeChildSession(options: {
       sessionId: childSessionId,
       preconfig,
       messages,
-      workspacePath,
-      workspaceId,
+      workspacePath: effectiveWorkspacePath,
+      workspaceId: effectiveWorkspaceId,
       additionalPaths,
       modelId: modelId ?? undefined,
       providerId: providerId ?? undefined,

package/src/subagent/task-tool.ts

@@ -429,6 +429,7 @@ async function runSubagent(
       childSession = await createSessionFn({
         id: randomUUID(),
         workspaceId: workspaceId || parentSession?.workspaceId || '',
+        workspaceRootId: parentSession?.workspaceRootId ?? null,
         preconfigId: subagent_type,
         title: `${description} (@${subagent_type} subagent)`,
         status: 'active',