@@ -147,6 +147,17 @@ console.log(`  - Cleanup Interval: ${finalConfig.CLEANUP_INTERVAL_MS}ms`);
 console.log(`  - Cleanup Max Age: ${finalConfig.CLEANUP_MAX_AGE_MS}ms`);
 console.log(`  - Debug: ${finalConfig.DEBUG ? 'Yes' : 'No'}`);
 
+// A rejected promise inside a request handler must not take the whole proxy down.
+// Node's default --unhandled-rejections=throw turns one bad request into a process
+// exit, which reads to users as "the service stopped working after a while".
+process.on('unhandledRejection', (reason) => {
+    const detail = reason instanceof Error
+        ? `${reason.name}: ${reason.message}`
+        : typeof reason === 'string' ? reason : JSON.stringify(reason);
+    console.error('[Proxy] Unhandled rejection (request dropped, server continues):', detail);
+    if (reason instanceof Error && reason.stack) console.error(reason.stack);
+});
+
 // Start the proxy
 try {
     const proxy = startProxy(finalConfig);
 
@@ -193,7 +193,10 @@ const STARTING_WAIT_ITERATIONS = 120;
 const STARTING_WAIT_INTERVAL_MS = 1000;
 const DEFAULT_REQUEST_TIMEOUT_MS = 300000;
 const DEFAULT_POLL_INTERVAL_MS = 500;
-const DEFAULT_EVENT_FIRST_DELTA_TIMEOUT_MS = 4000;
+// Reasoning models can take well over 10s before emitting their first token.
+// A short window here makes the event stream give up and fall back to polling on
+// every request, which loses true streaming. Configurable for slow backends.
+const DEFAULT_EVENT_FIRST_DELTA_TIMEOUT_MS = Number(process.env.OPENCODE2API_EVENT_FIRST_DELTA_TIMEOUT_MS) || 30000;
 const DEFAULT_EVENT_IDLE_TIMEOUT_MS = Number(process.env.OPENCODE2API_EVENT_IDLE_TIMEOUT_MS) || 8000;
 
 const OPENCODE_BASENAME = 'opencode';
@@ -1078,15 +1081,22 @@ export function createApp(config) {
     }
 
     function extractFromParts(parts) {
-        if (!Array.isArray(parts)) return { content: '', reasoning: '' };
+        if (!Array.isArray(parts)) return { content: '', reasoning: '', toolParts: [] };
         const content = parts.filter(p => p.type === 'text').map(p => p.text).join('');
         const reasoning = parts.filter(p => p.type === 'reasoning').map(p => p.text).join('');
-        return { content, reasoning };
+        const toolParts = parts.filter(p => p.type === 'tool');
+        return { content, reasoning, toolParts };
     }
 
     async function pollForAssistantResponse(sessionId, timeoutMs, intervalMs = DEFAULT_POLL_INTERVAL_MS) {
         const pollStart = Date.now();
         const startedAt = Date.now();
+        // Best-effort snapshot of the most recent in-flight assistant message. Polling
+        // observes partial messages: a reasoning model emits its reasoning part first and
+        // the text part only afterwards, so returning on the first non-empty snapshot
+        // truncates the answer to the reasoning alone. Keep the partial around purely as
+        // a timeout fallback and otherwise wait for the message to actually finish.
+        let lastPartial = null;
         while (Date.now() - startedAt < timeoutMs) {
             const messagesRes = await client.session.messages({ path: { id: sessionId } });
             const messages = messagesRes?.data || messagesRes || [];
@@ -1095,10 +1105,25 @@ export function createApp(config) {
                     const entry = messages[i];
                     const info = entry?.info;
                     if (info?.role !== 'assistant') continue;
-                    const { content, reasoning } = extractFromParts(entry?.parts || []);
+                    const { content, reasoning, toolParts } = extractFromParts(entry?.parts || []);
                     const error = info?.error || null;
-                    const done = Boolean(info.finish || info.time?.completed || error);
-                    if (done || content || reasoning) {
+                    // finish === 'tool' marks an intermediate turn that pauses for a tool
+                    // result; the assistant is not done producing output yet.
+                    const finished = info.finish && info.finish !== 'tool';
+                    const done = Boolean(finished || info.time?.completed || error);
+                    if (toolParts.length > 0) {
+                        logDebug('Polling found tool parts', {
+                            sessionId,
+                            count: toolParts.length,
+                            parts: toolParts.map(p => ({
+                                id: p.id,
+                                tool: p.tool,
+                                status: p.state?.status,
+                                input: p.state?.input
+                            }))
+                        });
+                    }
+                    if (done) {
                         if (error) {
                             console.error('[Proxy] OpenCode assistant error:', error);
                         }
@@ -1112,10 +1137,23 @@ export function createApp(config) {
                         });
                         return { content, reasoning, error };
                     }
+                    if (content || reasoning) {
+                        lastPartial = { content, reasoning, error: null };
+                    }
+                    break;
                 }
             }
             await sleep(intervalMs);
         }
+        if (lastPartial) {
+            logDebug('Polling timeout with partial response', {
+                sessionId,
+                ms: Date.now() - pollStart,
+                contentLen: lastPartial.content.length,
+                reasoningLen: lastPartial.reasoning.length
+            });
+            return lastPartial;
+        }
         logDebug('Polling timeout', { sessionId, ms: Date.now() - pollStart });
         throw new Error(`Request timeout after ${timeoutMs}ms`);
     }
@@ -1236,6 +1274,22 @@ export function createApp(config) {
                             event.properties.info.sessionID === sessionId) {
                             const info = event.properties.info;
                             const finish = info.finish;
+                            // An aborted or failed message never produces another delta. Without
+                            // this, the collector waits out the whole first-delta window before
+                            // polling rediscovers the same error.
+                            if (info.error && !finished) {
+                                finished = true;
+                                clearTimeout(timeoutId);
+                                if (firstDeltaTimer) clearTimeout(firstDeltaTimer);
+                                if (idleTimer) clearTimeout(idleTimer);
+                                logDebug('SSE upstream message error', {
+                                    sessionId,
+                                    ms: Date.now() - startedAt,
+                                    error: info.error.name || 'UnknownError'
+                                });
+                                resolve({ content, reasoning, error: info.error });
+                                break;
+                            }
                             // Reconcile active tool calls from the full message snapshot so we
                             // detect pending tools even when only message.updated fires.
                             if (Array.isArray(info.parts)) {
@@ -1523,7 +1577,13 @@ export function createApp(config) {
                         body: {
                             model: { providerID: pID, modelID: mID },
                             system: systemWithGuard,
-                            parts: parts,
+                            // Append a short contract reminder as the last part so the model
+                            // sees it immediately before generating. With the contract only in
+                            // the 16KB+ system prompt it gets buried; position matters a lot for
+                            // compliance. deepseek-v4-flash-free: 50% → 100% call rate.
+                            parts: externalToolContext.reminder
+                                ? [...parts, { type: 'text', text: externalToolContext.reminder }]
+                                : parts,
                             ...(requestParams.max_tokens && { max_tokens: requestParams.max_tokens }),
                             ...(requestParams.temperature !== undefined && { temperature: requestParams.temperature }),
                             ...(requestParams.top_p !== undefined && { top_p: requestParams.top_p }),
@@ -2239,7 +2299,9 @@ export function createApp(config) {
                 body: {
                     model: { providerID: pID, modelID: mID },
                     ...(systemWithGuard ? { system: systemWithGuard } : {}),
-                    parts,
+                    parts: externalToolContext.reminder
+                        ? [...parts, { type: 'text', text: externalToolContext.reminder }]
+                        : parts,
                     ...(max_output_tokens && { max_tokens: max_output_tokens }),
                     ...(temperature !== undefined && { temperature }),
                     ...(top_p !== undefined && { top_p })
@@ -2679,9 +2741,25 @@ export function createApp(config) {
 
             return res.json(response);
         } catch (error) {
-            console.error('[Proxy] Responses API Error:', error.message);
+            console.error('[Proxy] Responses API Error:', error?.message || error?.data?.message || error?.name || error);
             const transformed = transformUpstreamError(error);
-            res.status(transformed.statusCode).json(transformed.error);
+            // Once the SSE headers are out, res.json() throws ERR_HTTP_HEADERS_SENT. That throw
+            // escapes this async handler as an unhandled rejection, which terminates the whole
+            // process under Node's default --unhandled-rejections=throw. Report the failure on
+            // the already-open stream instead.
+            if (res.headersSent) {
+                try {
+                    res.write(`data: ${JSON.stringify({
+                        type: 'response.failed',
+                        response: { error: transformed.error.error || transformed.error }
+                    })}\n\n`);
+                    res.write('data: [DONE]\n\n');
+                } catch (writeError) {
+                    logDebug('Failed to report error on open response stream', { error: writeError.message });
+                }
+                return res.end();
+            }
+            return res.status(transformed.statusCode).json(transformed.error);
         }
     });
 
 
@@ -70,6 +70,18 @@ function registryNames(registry) {
     return [...names].sort((a, b) => b.length - a.length);
 }
 
+/** Map every accepted tool name (namespaced and original) to its declared JSON schema. */
+function registrySchemas(registry) {
+    const schemas = new Map();
+    if (!Array.isArray(registry)) return schemas;
+    registry.forEach((tool) => {
+        if (!tool?.parameters) return;
+        if (tool.namespacedName) schemas.set(tool.namespacedName, tool.parameters);
+        if (tool.originalName) schemas.set(tool.originalName, tool.parameters);
+    });
+    return schemas;
+}
+
 /**
  * DSML parameter bodies usually sit on their own line. Drop one leading and one trailing
  * newline so `<parameter>\nvalue\n</parameter>` yields "value", while interior whitespace
@@ -133,7 +145,16 @@ function rawCallsFromJsonText(text) {
     try {
         return rawCallsFromJsonPayload(JSON.parse(trimmed));
     } catch {
-        return [];
+        // The body may be prefixed by stray markup — a nested <function_calls> tag copied
+        // from the contract reminder, or a tool wrapper tag emitted by the model before
+        // the JSON payload. Scan for the first balanced JSON value and try again.
+        const found = findFirstJsonValue(trimmed);
+        if (!found) return [];
+        try {
+            return rawCallsFromJsonPayload(JSON.parse(found.json));
+        } catch {
+            return [];
+        }
     }
 }
 
@@ -270,6 +291,66 @@ function argsFromAttrs(attrs) {
     return null;
 }
 
+/**
+ * Coerce an XML child element's text using the declared JSON-schema type. A schema type of
+ * `string` is honoured verbatim so a path like `123.txt` or a body of JSON-looking text is
+ * not silently turned into a number or an object.
+ */
+function coerceSchemaValue(value, schema) {
+    const type = Array.isArray(schema?.type) ? schema.type[0] : schema?.type;
+    if (type === 'string') return value;
+    const trimmed = value.trim();
+    if (!trimmed) return value;
+    if (type === 'number' || type === 'integer') {
+        const num = Number(trimmed);
+        return Number.isFinite(num) ? num : value;
+    }
+    if (type === 'boolean') {
+        if (/^true$/i.test(trimmed)) return true;
+        if (/^false$/i.test(trimmed)) return false;
+        return value;
+    }
+    if (type === 'object' || type === 'array') {
+        try {
+            return JSON.parse(trimmed);
+        } catch {
+            return value;
+        }
+    }
+    // Untyped: fall back to the permissive decoding used elsewhere.
+    return coerceParamValue(value, '');
+}
+
+/**
+ * Arguments carried as XML child elements rather than JSON:
+ *
+ *   <read>
+ *     <path>a.txt</path>
+ *     <offset>10</offset>
+ *   </read>
+ *
+ * Widely used by Cline/Roo-style harnesses, so many models emit it from training even when
+ * asked for JSON. Only child names declared in the tool's own schema are accepted, which
+ * keeps prose containing angle brackets from being mistaken for arguments.
+ */
+function argsFromXmlChildren(body, parameters) {
+    const properties = parameters && typeof parameters === 'object' ? parameters.properties : null;
+    if (!properties || typeof properties !== 'object') return null;
+    const allowed = Object.keys(properties);
+    if (!allowed.length) return null;
+
+    const args = {};
+    let matched = 0;
+    for (const key of allowed) {
+        const re = new RegExp(`<${escapeRegExp(key)}\\s*>([\\s\\S]*?)</${escapeRegExp(key)}\\s*>`, 'i');
+        const found = body.match(re);
+        if (!found) continue;
+        matched += 1;
+        args[key] = coerceSchemaValue(trimParamValue(found[1]), properties[key]);
+    }
+    return matched > 0 ? args : null;
+}
+
 /**
  * End index of a tag's attribute region, skipping over quoted strings and balanced JSON
  * so that a `>` inside an attribute value (`arguments={"command":"ls > out"}`) does not
@@ -306,7 +387,7 @@ function findTagEnd(text, from) {
  * Registry-gated tag formats: `<tool .../>`, `<tool ...>body</tool>`, and an unclosed
  * `<tool ...>` followed by a JSON body.
  */
-function extractTagNamed(text, names) {
+function extractTagNamed(text, names, schemas = new Map()) {
     const calls = [];
     const spans = [];
     if (!names.length) return { calls, spans };
@@ -366,7 +447,11 @@ function extractTagNamed(text, names) {
                 }
             }
         } else {
-            calls.push({ name, arguments: {} });
+            // No JSON body. Arguments may still be present as XML child elements named
+            // after the schema's properties; dropping them here produced tool calls with
+            // empty arguments, which fail validation for any tool with required fields.
+            const xmlArgs = argsFromXmlChildren(body, schemas.get(name));
+            calls.push({ name, arguments: xmlArgs || {} });
         }
         spans.push([match.index, consumedEnd]);
     }
@@ -399,12 +484,13 @@ function collectAll(text, registry) {
     const source = typeof text === 'string' ? text : '';
     if (!source) return { calls: [], spans: [] };
     const names = registryNames(registry);
+    const schemas = registrySchemas(registry);
 
     const results = [
         extractCanonical(source),
         extractDsml(source),
         extractJsonWrapper(source),
-        extractTagNamed(source, names),
+        extractTagNamed(source, names, schemas),
         extractBareJson(source, names)
     ];