const std = @import("std");const build_options = @import("build_options");const acp_server = @import("acp/server.zig");const jsonrpc = @import("acp/jsonrpc.zig");const background_process_provider = @import("core/execution/background_process_provider.zig");const gateway_provider = @import("core/gateway/gateway_provider.zig");const generation_usage_provider = @import("core/session/generation_usage_provider.zig");const host = @import("core/hosts/host.zig");const debug_trace = @import("core/shared/debug_trace.zig");const io_mod = @import("core/shared/io.zig");const streamable_http = @import("core/mcp/streamable_http.zig");const host_stream_provider = @import("gateway/host_stream_provider.zig");const oauth_transport = @import("core/auth/oauth_transport.zig");const builtin_context = @import("builtins/context.zig");const builtin_gateway = @import("builtins/gateway.zig");const builtin_modes = @import("builtins/modes.zig"); const c = @cImport({ @cInclude("node_api.h");}); const Allocator = std.mem.Allocator;const max_drain_bytes = 1024 * 1024;const max_input_bytes = 8 * 1024 * 1024;const max_output_bytes = 8 * 1024 * 1024;const max_fetch_request_bytes = 8 * 1024 * 1024;const max_fetch_response_bytes = 8 * 1024 * 1024;const max_api_key_bytes = 64 * 1024;const max_model_bytes = 1024;const max_path_bytes = 16 * 1024;const max_url_bytes = 16 * 1024;const max_active_runtimes = 64;const runtime_handle_type_tag = c.napi_type_tag{ .lower = 0x4c4942465852544d, .upper = 0xa71d7c52e9314b08,}; comptime { if (build_options.napi_surface != .core) { @compileError("libfx N-API core requires -Dnapi-surface=core"); }} const InputQueue = struct { mutex: std.Io.Mutex = .init, wake: std.Io.Condition = .init, bytes: std.ArrayList(u8) = .empty, offset: usize = 0, closed: bool = false, fn read(self: *InputQueue, alloc: Allocator, destination: []u8) usize { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); while (self.offset == self.bytes.items.len and !self.closed) { self.bytes.clearRetainingCapacity(); self.offset = 0; self.wake.waitUncancelable(io, &self.mutex); } const available = self.bytes.items.len - self.offset; if (available == 0) return 0; const len = @min(destination.len, available); @memcpy(destination[0..len], self.bytes.items[self.offset..][0..len]); self.offset += len; if (self.offset == self.bytes.items.len) { self.bytes.clearRetainingCapacity(); self.offset = 0; } _ = alloc; return len; } fn write(self: *InputQueue, alloc: Allocator, data: []const u8) !void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); if (self.closed) return error.InputClosed; const queued = self.bytes.items.len - self.offset; if (data.len > max_input_bytes or queued > max_input_bytes - data.len) return error.InputQueueFull; if (self.offset > 0) { std.mem.copyForwards(u8, self.bytes.items[0..queued], self.bytes.items[self.offset..]); self.bytes.items.len = queued; self.offset = 0; } try self.bytes.appendSlice(alloc, data); self.wake.signal(io); } fn close(self: *InputQueue) void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); self.closed = true; self.wake.broadcast(io); self.mutex.unlock(io); } fn deinit(self: *InputQueue, alloc: Allocator) void { self.bytes.deinit(alloc); }}; const OutputQueue = struct { mutex: std.Io.Mutex = .init, bytes: std.ArrayList(u8) = .empty, offset: usize = 0, fn write(self: *OutputQueue, alloc: Allocator, data: []const u8) !void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); const queued = self.bytes.items.len - self.offset; if (data.len > max_output_bytes or queued > max_output_bytes - data.len) return error.OutputQueueFull; if (self.offset > 0) { std.mem.copyForwards(u8, self.bytes.items[0..queued], self.bytes.items[self.offset..]); self.bytes.items.len = queued; self.offset = 0; } try self.bytes.appendSlice(alloc, data); } fn drain(self: *OutputQueue, destination: []u8) usize { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); const available_bytes = self.bytes.items.len - self.offset; const len = @min(destination.len, available_bytes); if (len == 0) return 0; @memcpy(destination[0..len], self.bytes.items[self.offset..][0..len]); self.offset += len; if (self.offset == self.bytes.items.len) { self.bytes.clearRetainingCapacity(); self.offset = 0; } return len; } fn available(self: *OutputQueue) usize { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); return self.bytes.items.len - self.offset; } fn deinit(self: *OutputQueue, alloc: Allocator) void { self.bytes.deinit(alloc); }}; const FetchBridge = struct { mutex: std.Io.Mutex = .init, wake: std.Io.Condition = .init, request: std.ArrayList(u8) = .empty, response: std.ArrayList(u8) = .empty, response_offset: usize = 0, request_pending: bool = false, response_started: bool = false, response_done: bool = false, failed: bool = false, aborted: bool = false, shutting_down: bool = false, status: u16 = 0, fn clearPendingRequest(self: *FetchBridge, reason: []const u8) void { if (!self.request_pending) return; debug_trace.logf("napi", "dropping pending host fetch reason={s} bytes={d}", .{ reason, self.request.items.len }); self.request.clearRetainingCapacity(); self.request_pending = false; } fn open(raw: ?*anyopaque, method: []const u8, url: []const u8, headers: []const u8, body: []const u8) !i32 { const self: *FetchBridge = @ptrCast(@alignCast(raw.?)); const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); if (self.shutting_down) return error.HostStreamUnavailable; if (self.aborted) { self.clearPendingRequest("open_after_abort"); self.aborted = false; return error.Cancelled; } if (self.request_pending or self.response_started) return error.HostStreamUnavailable; self.failed = false; self.response_done = false; self.response_offset = 0; self.response.clearRetainingCapacity(); var writer: std.Io.Writer.Allocating = .init(std.heap.c_allocator); defer writer.deinit(); const encoded_body = std.base64.standard.Encoder.calcSize(body.len); const body_base64 = try std.heap.c_allocator.alloc(u8, encoded_body); defer std.heap.c_allocator.free(body_base64); _ = std.base64.standard.Encoder.encode(body_base64, body); try std.json.Stringify.value(.{ .method = method, .url = url, .headers = headers, .body = body_base64 }, .{}, &writer.writer); const bytes = writer.writer.buffered(); if (bytes.len > max_fetch_request_bytes) return error.HostStreamBackpressure; try self.request.appendSlice(std.heap.c_allocator, bytes); self.request_pending = true; self.wake.broadcast(io); return 1; } fn statusFn(raw: ?*anyopaque, _: i32, status_out: *u16) i32 { const self: *FetchBridge = @ptrCast(@alignCast(raw.?)); const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); while (!self.response_started and !self.aborted) self.wake.waitUncancelable(io, &self.mutex); if (self.aborted) return -2; if (self.failed) return -1; status_out.* = self.status; return 1; } fn next(raw: ?*anyopaque, _: i32, out: []u8) i32 { const self: *FetchBridge = @ptrCast(@alignCast(raw.?)); const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); while (self.response_offset == self.response.items.len and !self.response_done and !self.aborted) { self.response.clearRetainingCapacity(); self.response_offset = 0; self.wake.waitUncancelable(io, &self.mutex); } if (self.aborted) return -2; if (self.failed) return -1; const available = self.response.items.len - self.response_offset; if (available == 0) return 0; const len = @min(out.len, available); @memcpy(out[0..len], self.response.items[self.response_offset..][0..len]); self.response_offset += len; self.wake.broadcast(io); return @intCast(len); } fn close(raw: ?*anyopaque, _: i32) void { const self: *FetchBridge = @ptrCast(@alignCast(raw.?)); const io = io_mod.getIo(); self.mutex.lockUncancelable(io); self.clearPendingRequest("stream_close"); self.response_started = false; self.response_done = false; self.failed = false; self.aborted = false; self.response.clearRetainingCapacity(); self.response_offset = 0; self.wake.broadcast(io); self.mutex.unlock(io); } fn startResponse(self: *FetchBridge, status: u16) !void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); if (self.aborted) return error.FetchAborted; if (self.response_started) return error.ResponseAlreadyStarted; self.status = status; self.response_started = true; self.wake.broadcast(io); } fn pushResponse(self: *FetchBridge, data: []const u8) !void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); if (self.aborted) return error.FetchAborted; if (!self.response_started or self.response_done) return error.InvalidResponseState; const queued = self.response.items.len - self.response_offset; if (data.len > max_fetch_response_bytes or queued > max_fetch_response_bytes - data.len) return error.ResponseQueueFull; if (self.response_offset > 0) { std.mem.copyForwards(u8, self.response.items[0..queued], self.response.items[self.response_offset..]); self.response.items.len = queued; self.response_offset = 0; } try self.response.appendSlice(std.heap.c_allocator, data); self.wake.broadcast(io); } fn finishResponse(self: *FetchBridge) void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); self.response_done = true; self.wake.broadcast(io); self.mutex.unlock(io); } fn failResponse(self: *FetchBridge) void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); self.failed = true; self.response_started = true; self.response_done = true; self.wake.broadcast(io); self.mutex.unlock(io); } fn abort(self: *FetchBridge) void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); self.clearPendingRequest("abort"); self.aborted = true; self.wake.broadcast(io); self.mutex.unlock(io); } fn shutdown(self: *FetchBridge) void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); self.clearPendingRequest("shutdown"); self.shutting_down = true; self.aborted = true; self.wake.broadcast(io); self.mutex.unlock(io); } fn deinit(self: *FetchBridge) void { self.request.deinit(std.heap.c_allocator); self.response.deinit(std.heap.c_allocator); }}; const Runtime = struct { alloc: Allocator, fetch: FetchBridge = .{}, stream_context: host_stream_provider.ProviderContext = undefined, input: InputQueue = .{}, output: OutputQueue = .{}, credential: []u8, model: ?[]u8, home: []u8, workspace_root: []u8, gateway_chat_url: []u8, thread: std.Thread, exited: std.atomic.Value(bool) = .init(false), exit_code: std.atomic.Value(u8) = .init(0), fn readInput(context: ?*anyopaque, destination: []u8) usize { const self: *Runtime = @ptrCast(@alignCast(context.?)); return self.input.read(self.alloc, destination); } fn writeOutput(context: ?*anyopaque, bytes: []const u8) !void { const self: *Runtime = @ptrCast(@alignCast(context.?)); self.output.write(self.alloc, bytes) catch |err| { debug_trace.logf("napi", "native output failed err={s}", .{@errorName(err)}); self.exit_code.store(1, .seq_cst); return err; }; } fn run(self: *Runtime) void { const provider = gateway_provider.Provider{ .agent_stream = host_stream_provider.provider(&self.stream_context), .oauth_transport = oauth_transport.unavailable_provider, .chat_url = builtin_gateway.provider.chat_url, .cli_model_catalog = builtin_gateway.provider.cli_model_catalog, .credits = builtin_gateway.provider.credits, .generation_usage = generation_usage_provider.unavailable_provider, .web_search = builtin_gateway.provider.web_search, .model_catalog = builtin_gateway.provider.model_catalog, }; acp_server.runWithTransport( self.alloc, .{ .default_model = builtin_gateway.default_model, .default_agent_step_limit = 64, .gateway_retry_count = 0, .gateway_chat_url = self.gateway_chat_url, .gateway_models_path = builtin_gateway.models_path, .gateway_provider = provider, .background_process_provider = background_process_provider.unavailable_provider, .secret_store = host.unavailable_secret_store, .prompt_policy = builtin_context.prompt_policy, .ignored_list_entries = &.{}, .max_list_entries = 0, .max_read_file_bytes = 0, .max_read_file_lines = 0, .max_read_file_line_len = 0, .max_command_output_bytes = 0, .max_tool_result_bytes = 64 * 1024, .max_history_turns = 100, .context_registry = .{ .default_provider = builtin_context.provider }, .mode_registry = builtin_modes.registry, .credential_override = self.credential, .model_override = self.model, .home_override = self.home, .workspace_root_override = self.workspace_root, .allow_acp_mcp = false, .allow_native_tools = false, }, jsonrpc.Reader.initCallback(self, Runtime.readInput), jsonrpc.Writer.initCallback(self, Runtime.writeOutput), ) catch |err| { debug_trace.logf("napi", "native runtime failed err={s}", .{@errorName(err)}); self.exit_code.store(1, .seq_cst); }; self.exited.store(true, .seq_cst); } fn closeInput(self: *Runtime) void { self.input.close(); } fn abortHostEffects(self: *Runtime) void { self.fetch.abort(); } fn deinit(self: *Runtime) void { self.closeInput(); self.fetch.shutdown(); self.thread.join(); self.fetch.deinit(); self.input.deinit(self.alloc); self.output.deinit(self.alloc); self.alloc.free(self.credential); if (self.model) |model| self.alloc.free(model); self.alloc.free(self.home); self.alloc.free(self.workspace_root); self.alloc.free(self.gateway_chat_url); self.alloc.destroy(self); releaseRuntimeSlot(); }}; const RuntimeHandle = struct { mutex: std.Io.Mutex = .init, runtime: ?*Runtime, fn destroy(self: *RuntimeHandle) void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); const runtime = self.runtime; self.runtime = null; self.mutex.unlock(io); if (runtime) |value| value.deinit(); }}; var threaded_io: ?std.Io.Threaded = null;var threaded_io_state: std.atomic.Value(u8) = .init(0);var active_runtime_count: std.atomic.Value(usize) = .init(0); fn claimRuntimeSlot() bool { var current = active_runtime_count.load(.acquire); while (current < max_active_runtimes) { if (active_runtime_count.cmpxchgWeak(current, current + 1, .acq_rel, .acquire)) |observed| { current = observed; } else return true; } return false;} fn releaseRuntimeSlot() void { _ = active_runtime_count.fetchSub(1, .acq_rel);} fn ensureThreadedIo() void { if (threaded_io_state.cmpxchgStrong(0, 1, .acq_rel, .acquire) == null) { threaded_io = std.Io.Threaded.init(std.heap.c_allocator, .{}); io_mod.setIo(threaded_io.?.io()); threaded_io_state.store(2, .release); return; } while (threaded_io_state.load(.acquire) != 2) std.atomic.spinLoopHint();} fn throw(env: c.napi_env, code: [*:0]const u8, message: [*:0]const u8) c.napi_value { _ = c.napi_throw_error(env, code, message); return null;} fn statusOk(env: c.napi_env, status: c.napi_status, message: [*:0]const u8) bool { if (status == c.napi_ok) return true; _ = c.napi_throw_error(env, "LIBFX_NAPI", message); return false;} fn callbackArgs(env: c.napi_env, info: c.napi_callback_info, argv: []c.napi_value) bool { var argc = argv.len; if (!statusOk(env, c.napi_get_cb_info(env, info, &argc, argv.ptr, null, null), "could not read arguments")) return false; if (argc == argv.len) return true; _ = c.napi_throw_type_error(env, "LIBFX_INVALID_ARGUMENT", "missing required argument"); return false;} fn stringArg(env: c.napi_env, value: c.napi_value, alloc: Allocator, max_len: usize) ![]u8 { var len: usize = 0; if (c.napi_get_value_string_utf8(env, value, null, 0, &len) != c.napi_ok) return error.InvalidArgument; if (len > max_len) return error.ArgumentTooLong; const bytes = try alloc.alloc(u8, len + 1); errdefer alloc.free(bytes); var written: usize = 0; if (c.napi_get_value_string_utf8(env, value, bytes.ptr, bytes.len, &written) != c.napi_ok) return error.InvalidArgument; return bytes[0..written];} fn getNamedString( env: c.napi_env, object: c.napi_value, name: [*:0]const u8, alloc: Allocator, max_len: usize,Lines 1–500 of 852. Load more
const std = @import("std"); const build_options = @import("build_options"); const acp_server = @import("acp/server.zig"); const jsonrpc = @import("acp/jsonrpc.zig"); const background_process_provider = @import("core/execution/background_process_provider.zig"); const gateway_provider = @import("core/gateway/gateway_provider.zig"); const generation_usage_provider = @import("core/session/generation_usage_provider.zig"); const host = @import("core/hosts/host.zig"); const debug_trace = @import("core/shared/debug_trace.zig"); const io_mod = @import("core/shared/io.zig"); const streamable_http = @import("core/mcp/streamable_http.zig"); const host_stream_provider = @import("gateway/host_stream_provider.zig"); const oauth_transport = @import("core/auth/oauth_transport.zig"); const builtin_context = @import("builtins/context.zig"); const builtin_gateway = @import("builtins/gateway.zig"); const builtin_modes = @import("builtins/modes.zig"); const c = @cImport({ @cInclude("node_api.h"); }); const Allocator = std.mem.Allocator; const max_drain_bytes = 1024 * 1024; const max_input_bytes = 8 * 1024 * 1024; const max_output_bytes = 8 * 1024 * 1024; const max_fetch_request_bytes = 8 * 1024 * 1024; const max_fetch_response_bytes = 8 * 1024 * 1024; const max_api_key_bytes = 64 * 1024; const max_model_bytes = 1024; const max_path_bytes = 16 * 1024; const max_url_bytes = 16 * 1024; const max_active_runtimes = 64; const runtime_handle_type_tag = c.napi_type_tag{ .lower = 0x4c4942465852544d, .upper = 0xa71d7c52e9314b08, }; comptime { if (build_options.napi_surface != .core) { @compileError("libfx N-API core requires -Dnapi-surface=core"); } } const InputQueue = struct { mutex: std.Io.Mutex = .init, wake: std.Io.Condition = .init, bytes: std.ArrayList(u8) = .empty, offset: usize = 0, closed: bool = false, fn read(self: *InputQueue, alloc: Allocator, destination: []u8) usize { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); while (self.offset == self.bytes.items.len and !self.closed) { self.bytes.clearRetainingCapacity(); self.offset = 0; self.wake.waitUncancelable(io, &self.mutex); } const available = self.bytes.items.len - self.offset; if (available == 0) return 0; const len = @min(destination.len, available); @memcpy(destination[0..len], self.bytes.items[self.offset..][0..len]); self.offset += len; if (self.offset == self.bytes.items.len) { self.bytes.clearRetainingCapacity(); self.offset = 0; } _ = alloc; return len; } fn write(self: *InputQueue, alloc: Allocator, data: []const u8) !void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); if (self.closed) return error.InputClosed; const queued = self.bytes.items.len - self.offset; if (data.len > max_input_bytes or queued > max_input_bytes - data.len) return error.InputQueueFull; if (self.offset > 0) { std.mem.copyForwards(u8, self.bytes.items[0..queued], self.bytes.items[self.offset..]); self.bytes.items.len = queued; self.offset = 0; } try self.bytes.appendSlice(alloc, data); self.wake.signal(io); } fn close(self: *InputQueue) void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); self.closed = true; self.wake.broadcast(io); self.mutex.unlock(io); } fn deinit(self: *InputQueue, alloc: Allocator) void { self.bytes.deinit(alloc); } }; const OutputQueue = struct { mutex: std.Io.Mutex = .init, bytes: std.ArrayList(u8) = .empty, offset: usize = 0, fn write(self: *OutputQueue, alloc: Allocator, data: []const u8) !void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); const queued = self.bytes.items.len - self.offset; if (data.len > max_output_bytes or queued > max_output_bytes - data.len) return error.OutputQueueFull; if (self.offset > 0) { std.mem.copyForwards(u8, self.bytes.items[0..queued], self.bytes.items[self.offset..]); self.bytes.items.len = queued; self.offset = 0; } try self.bytes.appendSlice(alloc, data); } fn drain(self: *OutputQueue, destination: []u8) usize { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); const available_bytes = self.bytes.items.len - self.offset; const len = @min(destination.len, available_bytes); if (len == 0) return 0; @memcpy(destination[0..len], self.bytes.items[self.offset..][0..len]); self.offset += len; if (self.offset == self.bytes.items.len) { self.bytes.clearRetainingCapacity(); self.offset = 0; } return len; } fn available(self: *OutputQueue) usize { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); return self.bytes.items.len - self.offset; } fn deinit(self: *OutputQueue, alloc: Allocator) void { self.bytes.deinit(alloc); } }; const FetchBridge = struct { mutex: std.Io.Mutex = .init, wake: std.Io.Condition = .init, request: std.ArrayList(u8) = .empty, response: std.ArrayList(u8) = .empty, response_offset: usize = 0, request_pending: bool = false, response_started: bool = false, response_done: bool = false, failed: bool = false, aborted: bool = false, shutting_down: bool = false, status: u16 = 0, fn clearPendingRequest(self: *FetchBridge, reason: []const u8) void { if (!self.request_pending) return; debug_trace.logf("napi", "dropping pending host fetch reason={s} bytes={d}", .{ reason, self.request.items.len }); self.request.clearRetainingCapacity(); self.request_pending = false; } fn open(raw: ?*anyopaque, method: []const u8, url: []const u8, headers: []const u8, body: []const u8) !i32 { const self: *FetchBridge = @ptrCast(@alignCast(raw.?)); const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); if (self.shutting_down) return error.HostStreamUnavailable; if (self.aborted) { self.clearPendingRequest("open_after_abort"); self.aborted = false; return error.Cancelled; } if (self.request_pending or self.response_started) return error.HostStreamUnavailable; self.failed = false; self.response_done = false; self.response_offset = 0; self.response.clearRetainingCapacity(); var writer: std.Io.Writer.Allocating = .init(std.heap.c_allocator); defer writer.deinit(); const encoded_body = std.base64.standard.Encoder.calcSize(body.len); const body_base64 = try std.heap.c_allocator.alloc(u8, encoded_body); defer std.heap.c_allocator.free(body_base64); _ = std.base64.standard.Encoder.encode(body_base64, body); try std.json.Stringify.value(.{ .method = method, .url = url, .headers = headers, .body = body_base64 }, .{}, &writer.writer); const bytes = writer.writer.buffered(); if (bytes.len > max_fetch_request_bytes) return error.HostStreamBackpressure; try self.request.appendSlice(std.heap.c_allocator, bytes); self.request_pending = true; self.wake.broadcast(io); return 1; } fn statusFn(raw: ?*anyopaque, _: i32, status_out: *u16) i32 { const self: *FetchBridge = @ptrCast(@alignCast(raw.?)); const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); while (!self.response_started and !self.aborted) self.wake.waitUncancelable(io, &self.mutex); if (self.aborted) return -2; if (self.failed) return -1; status_out.* = self.status; return 1; } fn next(raw: ?*anyopaque, _: i32, out: []u8) i32 { const self: *FetchBridge = @ptrCast(@alignCast(raw.?)); const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); while (self.response_offset == self.response.items.len and !self.response_done and !self.aborted) { self.response.clearRetainingCapacity(); self.response_offset = 0; self.wake.waitUncancelable(io, &self.mutex); } if (self.aborted) return -2; if (self.failed) return -1; const available = self.response.items.len - self.response_offset; if (available == 0) return 0; const len = @min(out.len, available); @memcpy(out[0..len], self.response.items[self.response_offset..][0..len]); self.response_offset += len; self.wake.broadcast(io); return @intCast(len); } fn close(raw: ?*anyopaque, _: i32) void { const self: *FetchBridge = @ptrCast(@alignCast(raw.?)); const io = io_mod.getIo(); self.mutex.lockUncancelable(io); self.clearPendingRequest("stream_close"); self.response_started = false; self.response_done = false; self.failed = false; self.aborted = false; self.response.clearRetainingCapacity(); self.response_offset = 0; self.wake.broadcast(io); self.mutex.unlock(io); } fn startResponse(self: *FetchBridge, status: u16) !void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); if (self.aborted) return error.FetchAborted; if (self.response_started) return error.ResponseAlreadyStarted; self.status = status; self.response_started = true; self.wake.broadcast(io); } fn pushResponse(self: *FetchBridge, data: []const u8) !void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); defer self.mutex.unlock(io); if (self.aborted) return error.FetchAborted; if (!self.response_started or self.response_done) return error.InvalidResponseState; const queued = self.response.items.len - self.response_offset; if (data.len > max_fetch_response_bytes or queued > max_fetch_response_bytes - data.len) return error.ResponseQueueFull; if (self.response_offset > 0) { std.mem.copyForwards(u8, self.response.items[0..queued], self.response.items[self.response_offset..]); self.response.items.len = queued; self.response_offset = 0; } try self.response.appendSlice(std.heap.c_allocator, data); self.wake.broadcast(io); } fn finishResponse(self: *FetchBridge) void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); self.response_done = true; self.wake.broadcast(io); self.mutex.unlock(io); } fn failResponse(self: *FetchBridge) void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); self.failed = true; self.response_started = true; self.response_done = true; self.wake.broadcast(io); self.mutex.unlock(io); } fn abort(self: *FetchBridge) void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); self.clearPendingRequest("abort"); self.aborted = true; self.wake.broadcast(io); self.mutex.unlock(io); } fn shutdown(self: *FetchBridge) void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); self.clearPendingRequest("shutdown"); self.shutting_down = true; self.aborted = true; self.wake.broadcast(io); self.mutex.unlock(io); } fn deinit(self: *FetchBridge) void { self.request.deinit(std.heap.c_allocator); self.response.deinit(std.heap.c_allocator); } }; const Runtime = struct { alloc: Allocator, fetch: FetchBridge = .{}, stream_context: host_stream_provider.ProviderContext = undefined, input: InputQueue = .{}, output: OutputQueue = .{}, credential: []u8, model: ?[]u8, home: []u8, workspace_root: []u8, gateway_chat_url: []u8, thread: std.Thread, exited: std.atomic.Value(bool) = .init(false), exit_code: std.atomic.Value(u8) = .init(0), fn readInput(context: ?*anyopaque, destination: []u8) usize { const self: *Runtime = @ptrCast(@alignCast(context.?)); return self.input.read(self.alloc, destination); } fn writeOutput(context: ?*anyopaque, bytes: []const u8) !void { const self: *Runtime = @ptrCast(@alignCast(context.?)); self.output.write(self.alloc, bytes) catch |err| { debug_trace.logf("napi", "native output failed err={s}", .{@errorName(err)}); self.exit_code.store(1, .seq_cst); return err; }; } fn run(self: *Runtime) void { const provider = gateway_provider.Provider{ .agent_stream = host_stream_provider.provider(&self.stream_context), .oauth_transport = oauth_transport.unavailable_provider, .chat_url = builtin_gateway.provider.chat_url, .cli_model_catalog = builtin_gateway.provider.cli_model_catalog, .credits = builtin_gateway.provider.credits, .generation_usage = generation_usage_provider.unavailable_provider, .web_search = builtin_gateway.provider.web_search, .model_catalog = builtin_gateway.provider.model_catalog, }; acp_server.runWithTransport( self.alloc, .{ .default_model = builtin_gateway.default_model, .default_agent_step_limit = 64, .gateway_retry_count = 0, .gateway_chat_url = self.gateway_chat_url, .gateway_models_path = builtin_gateway.models_path, .gateway_provider = provider, .background_process_provider = background_process_provider.unavailable_provider, .secret_store = host.unavailable_secret_store, .prompt_policy = builtin_context.prompt_policy, .ignored_list_entries = &.{}, .max_list_entries = 0, .max_read_file_bytes = 0, .max_read_file_lines = 0, .max_read_file_line_len = 0, .max_command_output_bytes = 0, .max_tool_result_bytes = 64 * 1024, .max_history_turns = 100, .context_registry = .{ .default_provider = builtin_context.provider }, .mode_registry = builtin_modes.registry, .credential_override = self.credential, .model_override = self.model, .home_override = self.home, .workspace_root_override = self.workspace_root, .allow_acp_mcp = false, .allow_native_tools = false, }, jsonrpc.Reader.initCallback(self, Runtime.readInput), jsonrpc.Writer.initCallback(self, Runtime.writeOutput), ) catch |err| { debug_trace.logf("napi", "native runtime failed err={s}", .{@errorName(err)}); self.exit_code.store(1, .seq_cst); }; self.exited.store(true, .seq_cst); } fn closeInput(self: *Runtime) void { self.input.close(); } fn abortHostEffects(self: *Runtime) void { self.fetch.abort(); } fn deinit(self: *Runtime) void { self.closeInput(); self.fetch.shutdown(); self.thread.join(); self.fetch.deinit(); self.input.deinit(self.alloc); self.output.deinit(self.alloc); self.alloc.free(self.credential); if (self.model) |model| self.alloc.free(model); self.alloc.free(self.home); self.alloc.free(self.workspace_root); self.alloc.free(self.gateway_chat_url); self.alloc.destroy(self); releaseRuntimeSlot(); } }; const RuntimeHandle = struct { mutex: std.Io.Mutex = .init, runtime: ?*Runtime, fn destroy(self: *RuntimeHandle) void { const io = io_mod.getIo(); self.mutex.lockUncancelable(io); const runtime = self.runtime; self.runtime = null; self.mutex.unlock(io); if (runtime) |value| value.deinit(); } }; var threaded_io: ?std.Io.Threaded = null; var threaded_io_state: std.atomic.Value(u8) = .init(0); var active_runtime_count: std.atomic.Value(usize) = .init(0); fn claimRuntimeSlot() bool { var current = active_runtime_count.load(.acquire); while (current < max_active_runtimes) { if (active_runtime_count.cmpxchgWeak(current, current + 1, .acq_rel, .acquire)) |observed| { current = observed; } else return true; } return false; } fn releaseRuntimeSlot() void { _ = active_runtime_count.fetchSub(1, .acq_rel); } fn ensureThreadedIo() void { if (threaded_io_state.cmpxchgStrong(0, 1, .acq_rel, .acquire) == null) { threaded_io = std.Io.Threaded.init(std.heap.c_allocator, .{}); io_mod.setIo(threaded_io.?.io()); threaded_io_state.store(2, .release); return; } while (threaded_io_state.load(.acquire) != 2) std.atomic.spinLoopHint(); } fn throw(env: c.napi_env, code: [*:0]const u8, message: [*:0]const u8) c.napi_value { _ = c.napi_throw_error(env, code, message); return null; } fn statusOk(env: c.napi_env, status: c.napi_status, message: [*:0]const u8) bool { if (status == c.napi_ok) return true; _ = c.napi_throw_error(env, "LIBFX_NAPI", message); return false; } fn callbackArgs(env: c.napi_env, info: c.napi_callback_info, argv: []c.napi_value) bool { var argc = argv.len; if (!statusOk(env, c.napi_get_cb_info(env, info, &argc, argv.ptr, null, null), "could not read arguments")) return false; if (argc == argv.len) return true; _ = c.napi_throw_type_error(env, "LIBFX_INVALID_ARGUMENT", "missing required argument"); return false; } fn stringArg(env: c.napi_env, value: c.napi_value, alloc: Allocator, max_len: usize) ![]u8 { var len: usize = 0; if (c.napi_get_value_string_utf8(env, value, null, 0, &len) != c.napi_ok) return error.InvalidArgument; if (len > max_len) return error.ArgumentTooLong; const bytes = try alloc.alloc(u8, len + 1); errdefer alloc.free(bytes); var written: usize = 0; if (c.napi_get_value_string_utf8(env, value, bytes.ptr, bytes.len, &written) != c.napi_ok) return error.InvalidArgument; return bytes[0..written]; } fn getNamedString( env: c.napi_env, object: c.napi_value, name: [*:0]const u8, alloc: Allocator, max_len: usize,