@fased/fased 0.1.57 → 0.1.59

package/dist/agents/pi-embedded-runner/compact.js

@@ -30,6 +30,7 @@ import { resolveFasedAgentDocsPath } from "../docs-path.js";
 import { createPreparedEmbeddedPiSettingsManager } from "../pi-project-settings.js";
 import { detectRuntimeShell } from "../shell-utils.js";
 import { createFasedAgentCodingTools } from "../pi-tools.js";
+import { registerProviderStreamForModel } from "../provider-stream.js";
 import { repairSessionFileIfNeeded } from "../session-file-repair.js";
 import { log } from "./logger.js";
 import { sanitizeToolUseResultPairing } from "../session-transcript-repair.js";
@@ -436,6 +437,14 @@ async function compactEmbeddedPiSessionDirect(params) {
 				tools,
 				sandboxEnabled: !!sandbox?.enabled
 			});
+			if (model.api === "ollama") {
+				registerProviderStreamForModel({
+					model,
+					cfg: params.config,
+					agentDir,
+					workspaceDir: params.workspaceDir
+				});
+			}
 			const { session } = await createAgentSession({
 				cwd: resolvedWorkspace,
 				agentDir,

package/dist/agents/pi-embedded-runner/run/attempt.js

@@ -33,6 +33,7 @@ import { isTimeoutError } from "../../failover-error.js";
 import { resolveSandboxRuntimeStatus } from "../../sandbox/runtime-status.js";
 import { resolveEffectiveToolFsWorkspaceOnly } from "../../tool-fs-policy.js";
 import { createFasedAgentCodingTools, filterToolsByDisabledToolNames, resolveToolLoopDetectionConfig } from "../../pi-tools.js";
+import { registerProviderStreamForModel } from "../../provider-stream.js";
 import { repairSessionFileIfNeeded } from "../../session-file-repair.js";
 import { log } from "../logger.js";
 import { sanitizeToolCallIdsForCloudCodeAssist } from "../../tool-call-id.js";
@@ -580,6 +581,14 @@ async function runEmbeddedAttempt(params) {
 				loopDetection: clientToolLoopDetection
 			}) : [];
 			const allCustomTools = [...customTools, ...clientToolDefs];
+			if (params.model.api === "ollama") {
+				registerProviderStreamForModel({
+					model: params.model,
+					cfg: params.config,
+					agentDir,
+					workspaceDir: params.workspaceDir
+				});
+			}
 			({session} = await createAgentSession({
 				cwd: resolvedWorkspace,
 				agentDir,

package/dist/agents/pi-embedded-runner/session-manager-init.js

@@ -1,33 +1,18 @@
-import fs from "node:fs/promises";
-
 //#region src/agents/pi-embedded-runner/session-manager-init.ts
 /**
-* pi-coding-agent SessionManager persistence quirk:
-* - If the file exists but has no assistant message, SessionManager marks itself `flushed=true`
-*   and will never persist the initial user message.
-* - If the file doesn't exist yet, SessionManager builds a new session in memory and flushes
-*   header+user+assistant once the first assistant arrives (good).
-*
-* This normalizes the file/session state so the first user prompt is persisted before the first
-* assistant entry, even for pre-created session files.
+* Keep Fased's requested identity for new transcripts while leaving existing
+* transcripts under SessionManager's append lifecycle. In particular, an
+* existing header-only file is already marked flushed by SessionManager and
+* must not be truncated or reset to unflushed: its next assistant write uses
+* exclusive creation and would fail with EEXIST.
 */
 async function prepareSessionManagerForRun(params) {
 	const sm = params.sessionManager;
 	const header = sm.fileEntries.find((e) => e.type === "session");
-	const hasAssistant = sm.fileEntries.some((e) => e.type === "message" && e.message?.role === "assistant");
 	if (!params.hadSessionFile && header) {
 		header.id = params.sessionId;
 		header.cwd = params.cwd;
 		sm.sessionId = params.sessionId;
-		return;
-	}
-	if (params.hadSessionFile && header && !hasAssistant) {
-		await fs.writeFile(params.sessionFile, "", "utf-8");
-		sm.fileEntries = [header];
-		sm.byId?.clear?.();
-		sm.labelsById?.clear?.();
-		sm.leafId = null;
-		sm.flushed = false;
 	}
 }
 

package/dist/agents/provider-extension-catalog-manifest.js

@@ -56,8 +56,8 @@ const FASED_PROVIDER_EXTENSION_CATALOG_MANIFEST = [
 		upstreamProviderId: "kimi-coding",
 		upstreamCatalogPaths: ["extensions/kimi-coding/provider-catalog.ts"],
 		status: "mapped",
-		fasedProviderIds: ["kimi"],
-		fasedProviderAliases: ["kimi-coding", "kimi-code"],
+		fasedProviderIds: ["kimi-coding"],
+		fasedProviderAliases: ["kimi", "kimi-code"],
 		docsPath: "docs/providers/moonshot.md",
 		authSurface: "api-key",
 		authChoiceIds: ["kimi-code-api-key"]

package/dist/agents/provider-request-config.js

@@ -460,4 +460,4 @@ function getModelProviderRequestTransport(model) {
 }
 
 //#endregion
-export { attachModelProviderRequestTransport, sanitizeConfiguredModelProviderRequest };
+export { attachModelProviderRequestTransport, buildProviderRequestDispatcherPolicy, getModelProviderRequestTransport, resolveProviderRequestPolicyConfig, sanitizeConfiguredModelProviderRequest };

package/dist/agents/provider-stream.js

@@ -0,0 +1,29 @@
+import { resolveProviderStreamFn } from "../plugins/provider-runtime.js";
+import { ensureCustomApiRegistered } from "./custom-api-registry.js";
+import { createTransportAwareStreamFnForModel } from "./provider-transport-stream.js";
+
+//#region src/agents/provider-stream.ts
+function registerProviderStreamForModel(params) {
+	const streamFn = resolveProviderStreamFn({
+		provider: params.model.provider,
+		config: params.cfg,
+		workspaceDir: params.workspaceDir,
+		env: params.env,
+		context: {
+			config: params.cfg,
+			agentDir: params.agentDir,
+			workspaceDir: params.workspaceDir,
+			provider: params.model.provider,
+			modelId: params.model.id,
+			model: params.model
+		}
+	}) ?? createTransportAwareStreamFnForModel(params.model);
+	if (!streamFn) {
+		return undefined;
+	}
+	ensureCustomApiRegistered(params.model.api, streamFn);
+	return streamFn;
+}
+
+//#endregion
+export { registerProviderStreamForModel };

package/dist/agents/provider-transport-fetch.js

@@ -0,0 +1,89 @@
+import { fetchWithSsrFGuard } from "../infra/net/fetch-guard.js";
+import { buildProviderRequestDispatcherPolicy, getModelProviderRequestTransport, resolveProviderRequestPolicyConfig } from "./provider-request-config.js";
+
+//#region src/agents/provider-transport-fetch.ts
+function buildManagedResponse(response, release) {
+	if (!response.body) {
+		void release();
+		return response;
+	}
+	const source = response.body;
+	let reader;
+	let released = false;
+	const finalize = async () => {
+		if (released) {
+			return;
+		}
+		released = true;
+		await release().catch(() => undefined);
+	};
+	const wrappedBody = new ReadableStream({
+		start() {
+			reader = source.getReader();
+		},
+		async pull(controller) {
+			try {
+				const chunk = await reader?.read();
+				if (!chunk || chunk.done) {
+					controller.close();
+					await finalize();
+					return;
+				}
+				controller.enqueue(chunk.value);
+			} catch (error) {
+				controller.error(error);
+				await finalize();
+			}
+		},
+		async cancel(reason) {
+			try {
+				await reader?.cancel(reason);
+			} finally {
+				await finalize();
+			}
+		}
+	});
+	return new Response(wrappedBody, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers
+	});
+}
+function resolveModelRequestPolicy(model) {
+	return resolveProviderRequestPolicyConfig({
+		provider: model.provider,
+		api: model.api,
+		baseUrl: model.baseUrl,
+		capability: "llm",
+		transport: "stream",
+		request: getModelProviderRequestTransport(model)
+	});
+}
+function buildGuardedModelFetch(model) {
+	const requestConfig = resolveModelRequestPolicy(model);
+	const dispatcherPolicy = buildProviderRequestDispatcherPolicy(requestConfig);
+	return async (input, init) => {
+		const request = input instanceof Request ? new Request(input, init) : undefined;
+		const url = request?.url ?? (input instanceof URL ? input.toString() : typeof input === "string" ? input : (() => {
+			throw new Error("Unsupported fetch input for transport-aware model request");
+		})());
+		const requestInit = request && {
+			method: request.method,
+			headers: request.headers,
+			body: request.body ?? undefined,
+			redirect: request.redirect,
+			signal: request.signal,
+			...request.body ? { duplex: "half" } : {}
+		};
+		const result = await fetchWithSsrFGuard({
+			url,
+			init: requestInit ?? init,
+			dispatcherPolicy,
+			...requestConfig.allowPrivateNetwork ? { policy: { allowPrivateNetwork: true } } : {}
+		});
+		return buildManagedResponse(result.response, result.release);
+	};
+}
+
+//#endregion
+export { buildGuardedModelFetch };

package/dist/agents/provider-transport-stream.js

@@ -0,0 +1,72 @@
+import { getModelProviderRequestTransport } from "./provider-request-config.js";
+import { createAnthropicMessagesTransportStreamFn } from "./anthropic-transport-stream.js";
+import { createGoogleGenerativeAiTransportStreamFn } from "./google-transport-stream.js";
+import { createOpenAICompletionsTransportStreamFn, createOpenAIResponsesTransportStreamFn } from "./openai-transport-stream.js";
+
+//#region src/agents/provider-transport-stream.ts
+const SUPPORTED_TRANSPORT_APIS = new Set([
+	"openai-responses",
+	"openai-codex-responses",
+	"openai-completions",
+	"anthropic-messages",
+	"google-generative-ai"
+]);
+const SIMPLE_TRANSPORT_API_ALIAS = {
+	"openai-responses": "fased-openai-responses-transport",
+	"openai-codex-responses": "fased-openai-responses-transport",
+	"openai-completions": "fased-openai-completions-transport",
+	"anthropic-messages": "fased-anthropic-messages-transport",
+	"google-generative-ai": "fased-google-generative-ai-transport"
+};
+function createSupportedTransportStreamFn(api) {
+	switch (api) {
+		case "openai-responses":
+		case "openai-codex-responses": return createOpenAIResponsesTransportStreamFn();
+		case "openai-completions": return createOpenAICompletionsTransportStreamFn();
+		case "anthropic-messages": return createAnthropicMessagesTransportStreamFn();
+		case "google-generative-ai": return createGoogleGenerativeAiTransportStreamFn();
+		default: return undefined;
+	}
+}
+function hasTransportOverrides(model) {
+	const request = getModelProviderRequestTransport(model);
+	return Boolean(request?.proxy || request?.tls || request?.allowPrivateNetwork !== undefined);
+}
+function isTransportAwareApiSupported(api) {
+	return SUPPORTED_TRANSPORT_APIS.has(api);
+}
+function resolveTransportAwareSimpleApi(api) {
+	return SIMPLE_TRANSPORT_API_ALIAS[api];
+}
+function createTransportAwareStreamFnForModel(model) {
+	if (!hasTransportOverrides(model)) {
+		return undefined;
+	}
+	if (!isTransportAwareApiSupported(model.api)) {
+		throw new Error(`Model-provider request controls are not yet supported for api "${model.api}"`);
+	}
+	return createSupportedTransportStreamFn(model.api);
+}
+function createBoundaryAwareStreamFnForModel(model) {
+	if (!isTransportAwareApiSupported(model.api)) {
+		return undefined;
+	}
+	return createSupportedTransportStreamFn(model.api);
+}
+function prepareTransportAwareSimpleModel(model) {
+	const streamFn = createTransportAwareStreamFnForModel(model);
+	const alias = resolveTransportAwareSimpleApi(model.api);
+	if (!streamFn || !alias) {
+		return model;
+	}
+	return {
+		...model,
+		api: alias
+	};
+}
+function buildTransportAwareSimpleStreamFn(model) {
+	return createTransportAwareStreamFnForModel(model);
+}
+
+//#endregion
+export { createTransportAwareStreamFnForModel };

package/dist/agents/system-prompt-cache-boundary.js

@@ -32,4 +32,4 @@ function prependSystemPromptAdditionAfterCacheBoundary(params) {
 }
 
 //#endregion
-export { SYSTEM_PROMPT_CACHE_BOUNDARY };
+export { SYSTEM_PROMPT_CACHE_BOUNDARY, splitSystemPromptCacheBoundary, stripSystemPromptCacheBoundary };

package/dist/agents/system-prompt.js

@@ -1,8 +1,8 @@
 import { listDeliverableMessageChannels } from "../utils/message-channel.js";
 import { SILENT_REPLY_TOKEN } from "../auto-reply/tokens.js";
 import { normalizePromptCapabilityIds, normalizeStructuredPromptSection } from "./prompt-cache-stability.js";
-import { sanitizeForPromptLiteral } from "./sanitize-for-prompt.js";
 import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "./system-prompt-cache-boundary.js";
+import { sanitizeForPromptLiteral } from "./sanitize-for-prompt.js";
 import { createHash, createHmac } from "node:crypto";
 
 //#region src/agents/system-prompt.ts

package/dist/agents/transport-message-transform.js

@@ -0,0 +1,143 @@
+//#region src/agents/transport-message-transform.ts
+function transformTransportMessages(messages, model, normalizeToolCallId) {
+	const toolCallIdMap = new Map();
+	const transformed = messages.map((msg) => {
+		if (msg.role === "user") {
+			return msg;
+		}
+		if (msg.role === "toolResult") {
+			const normalizedId = toolCallIdMap.get(msg.toolCallId);
+			return normalizedId && normalizedId !== msg.toolCallId ? {
+				...msg,
+				toolCallId: normalizedId
+			} : msg;
+		}
+		if (msg.role !== "assistant") {
+			return msg;
+		}
+		const isSameModel = msg.provider === model.provider && msg.api === model.api && msg.model === model.id;
+		const content = [];
+		for (const block of msg.content) {
+			if (block.type === "thinking") {
+				const thinkingBlock = block;
+				if (thinkingBlock.redacted) {
+					if (isSameModel) {
+						content.push(thinkingBlock);
+					}
+					continue;
+				}
+				if (isSameModel && block.thinkingSignature) {
+					content.push(block);
+					continue;
+				}
+				if (!block.thinking.trim()) {
+					continue;
+				}
+				content.push(isSameModel ? block : {
+					type: "text",
+					text: block.thinking
+				});
+				continue;
+			}
+			if (block.type === "text") {
+				content.push(isSameModel ? block : {
+					type: "text",
+					text: block.text
+				});
+				continue;
+			}
+			if (block.type !== "toolCall") {
+				content.push(block);
+				continue;
+			}
+			let normalizedToolCall = block;
+			if (!isSameModel && block.thoughtSignature) {
+				normalizedToolCall = { ...normalizedToolCall };
+				delete normalizedToolCall.thoughtSignature;
+			}
+			if (!isSameModel && normalizeToolCallId) {
+				const normalizedId = normalizeToolCallId(block.id, model, msg);
+				if (normalizedId !== block.id) {
+					toolCallIdMap.set(block.id, normalizedId);
+					normalizedToolCall = {
+						...normalizedToolCall,
+						id: normalizedId
+					};
+				}
+			}
+			content.push(normalizedToolCall);
+		}
+		return {
+			...msg,
+			content
+		};
+	});
+	const result = [];
+	let pendingToolCalls = [];
+	let existingToolResultIds = new Set();
+	for (const msg of transformed) {
+		if (msg.role === "assistant") {
+			if (pendingToolCalls.length > 0) {
+				for (const toolCall of pendingToolCalls) {
+					if (!existingToolResultIds.has(toolCall.id)) {
+						result.push({
+							role: "toolResult",
+							toolCallId: toolCall.id,
+							toolName: toolCall.name,
+							content: [{
+								type: "text",
+								text: "No result provided"
+							}],
+							isError: true,
+							timestamp: Date.now()
+						});
+					}
+				}
+				pendingToolCalls = [];
+				existingToolResultIds = new Set();
+			}
+			if (msg.stopReason === "error" || msg.stopReason === "aborted") {
+				continue;
+			}
+			const toolCalls = msg.content.filter((block) => block.type === "toolCall");
+			if (toolCalls.length > 0) {
+				pendingToolCalls = toolCalls.map((block) => ({
+					id: block.id,
+					name: block.name
+				}));
+				existingToolResultIds = new Set();
+			}
+			result.push(msg);
+			continue;
+		}
+		if (msg.role === "toolResult") {
+			existingToolResultIds.add(msg.toolCallId);
+			result.push(msg);
+			continue;
+		}
+		if (pendingToolCalls.length > 0) {
+			for (const toolCall of pendingToolCalls) {
+				if (!existingToolResultIds.has(toolCall.id)) {
+					result.push({
+						role: "toolResult",
+						toolCallId: toolCall.id,
+						toolName: toolCall.name,
+						content: [{
+							type: "text",
+							text: "No result provided"
+						}],
+						isError: true,
+						timestamp: Date.now()
+					});
+				}
+			}
+			pendingToolCalls = [];
+			existingToolResultIds = new Set();
+		}
+		result.push(msg);
+	}
+	return result;
+}
+
+//#endregion
+export { transformTransportMessages };

package/dist/agents/transport-stream-shared.js

@@ -0,0 +1,81 @@
+import { createAssistantMessageEventStream } from "@mariozechner/pi-ai/compat";
+
+//#region src/agents/transport-stream-shared.ts
+function sanitizeTransportPayloadText(text) {
+	return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
+}
+function mergeTransportHeaders(...headerSources) {
+	const merged = {};
+	for (const headers of headerSources) {
+		if (headers) {
+			Object.assign(merged, headers);
+		}
+	}
+	return Object.keys(merged).length > 0 ? merged : undefined;
+}
+function mergeTransportMetadata(payload, metadata) {
+	if (!metadata || Object.keys(metadata).length === 0) {
+		return payload;
+	}
+	const existingMetadata = payload.metadata && typeof payload.metadata === "object" && !Array.isArray(payload.metadata) ? payload.metadata : undefined;
+	return {
+		...payload,
+		metadata: {
+			...existingMetadata,
+			...metadata
+		}
+	};
+}
+function createEmptyTransportUsage() {
+	return {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens: 0,
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			total: 0
+		}
+	};
+}
+function createWritableTransportEventStream() {
+	const eventStream = createAssistantMessageEventStream();
+	return {
+		eventStream,
+		stream: eventStream
+	};
+}
+function finalizeTransportStream(params) {
+	const { stream, output, signal } = params;
+	if (signal?.aborted) {
+		throw new Error("Request was aborted");
+	}
+	if (output.stopReason === "aborted" || output.stopReason === "error") {
+		throw new Error("An unknown error occurred");
+	}
+	stream.push({
+		type: "done",
+		reason: output.stopReason,
+		message: output
+	});
+	stream.end();
+}
+function failTransportStream(params) {
+	const { stream, output, signal, error, cleanup } = params;
+	cleanup?.();
+	output.stopReason = signal?.aborted ? "aborted" : "error";
+	output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+	stream.push({
+		type: "error",
+		reason: output.stopReason,
+		error: output
+	});
+	stream.end();
+}
+
+//#endregion
+export { createEmptyTransportUsage, createWritableTransportEventStream, failTransportStream, finalizeTransportStream, mergeTransportHeaders, mergeTransportMetadata, sanitizeTransportPayloadText };

package/dist/brand.js

@@ -2,7 +2,7 @@
 const FASED_BRAND_NAME = "Fased";
 const FASED_AGENT_NAME = "Fased Agent";
 const FASED_CONTROL_NAME = "Fased Control";
-const FASED_PRODUCT_VERSION = "0.1.57";
+const FASED_PRODUCT_VERSION = "0.1.59";
 const FASED_DISPLAY_VERSION = `v${FASED_PRODUCT_VERSION}`;
 function formatFasedDisplayLine() {
 	return `${FASED_AGENT_NAME} ${FASED_DISPLAY_VERSION}`;

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.57",
-  "commit": "91e53d4b2c1ca02701eff503d93e889ccfaab43d",
-  "builtAt": "2026-07-13T13:04:23.327Z"
+  "version": "0.1.59",
+  "commit": "52ee044888a4c31c2e7ee6958d86a61a1afdd081",
+  "builtAt": "2026-07-13T20:07:25.934Z"
 }

package/dist/canvas-host/a2ui/.bundle.hash

@@ -1 +1 @@
-bfd05e986c05a91921422f61d2871d036c3e2622a756b89cd75c7ba92ccf4947
+03f1c6c4f9975b6d14e5cf7e79d871c44fab07eb079c05ec45b191f8eab384cd

package/dist/channels/delivery.js

@@ -0,0 +1,78 @@
+//#region src/channels/delivery.ts
+const CHANNEL_DELIVERIES = [
+	"official-addon",
+	"bundled",
+	"source-only",
+	"external-prerequisite"
+];
+const CHANNEL_DELIVERY_ENTRIES = [
+	...[
+		"telegram",
+		"whatsapp",
+		"discord",
+		"slack",
+		"feishu",
+		"googlechat"
+	].map((id) => ({
+		id,
+		docsPath: `/channels/${id}`,
+		delivery: "official-addon"
+	})),
+	...[
+		"irc",
+		"line",
+		"mattermost",
+		"msteams",
+		"nextcloud-talk",
+		"synology-chat",
+		"zalo",
+		"zalouser"
+	].map((id) => ({
+		id,
+		docsPath: `/channels/${id}`,
+		delivery: "bundled"
+	})),
+	...[
+		"matrix",
+		"nostr",
+		"tlon",
+		"twitch"
+	].map((id) => ({
+		id,
+		docsPath: `/channels/${id}`,
+		delivery: "source-only"
+	})),
+	...[
+		"signal",
+		"imessage",
+		"bluebubbles"
+	].map((id) => ({
+		id,
+		docsPath: `/channels/${id}`,
+		delivery: "external-prerequisite"
+	}))
+];
+const DELIVERY_BY_ID = new Map(CHANNEL_DELIVERY_ENTRIES.map((entry) => [entry.id, entry]));
+function listChannelDeliveryEntries() {
+	return CHANNEL_DELIVERY_ENTRIES.map((entry) => ({ ...entry }));
+}
+function getChannelDeliveryEntry(id) {
+	return DELIVERY_BY_ID.get(id.trim().toLowerCase());
+}
+function getChannelDelivery(id) {
+	return getChannelDeliveryEntry(id)?.delivery ?? "source-only";
+}
+function formatChannelDelivery(delivery) {
+	switch (delivery) {
+		case "official-addon": return "Official add-on";
+		case "bundled": return "Bundled";
+		case "source-only": return "Source-only";
+		case "external-prerequisite": return "External prerequisite";
+	}
+}
+function channelDeliveryAllowsInstall(delivery) {
+	return delivery === "official-addon" || delivery === "bundled";
+}
+
+//#endregion
+export { channelDeliveryAllowsInstall, formatChannelDelivery, getChannelDelivery };