infinicode 2.8.26 → 2.8.27

package/dist/kernel/federation/federation.d.ts

@@ -251,6 +251,9 @@ export declare class Federation {
      * back (accept-only, never dials home).
      */
     private learnInboundPeer;
+    /** Connect with a longer manifest fetch timeout.  Inbound dial-backs often
+     *  cross Tailscale or Windows firewall, so the default 5s is too aggressive. */
+    private connectWithTimeout;
     /** Satellite: pull shared config from a freshly-connected hub/relay. */
     private maybeAutoPull;
     /** Satellite: re-pull from the first connected hub/relay (periodic refresh). */

package/dist/kernel/federation/federation.js

@@ -577,17 +577,38 @@ export class Federation {
             return; // already tracked
         if (this.inboundConnecting.has(from))
             return; // dial in flight
-        const port = env.data?.port;
-        const ip = normalizeIp(remote);
+        const data = env.data ?? {};
+        const port = data.port;
+        const ip = normalizeIp(data.ip ?? remote);
         if (!port || !ip)
             return;
         const url = `http://${ip}:${port}`;
         this.inboundConnecting.add(from);
         this.deps.logger.info(`[federation] learned inbound peer ${from} → dialing back ${url}`);
-        void this.connect(url)
+        void this.connectWithTimeout(url, 30_000)
             .catch(() => { })
             .finally(() => this.inboundConnecting.delete(from));
     }
+    /** Connect with a longer manifest fetch timeout.  Inbound dial-backs often
+     *  cross Tailscale or Windows firewall, so the default 5s is too aggressive. */
+    async connectWithTimeout(url, timeoutMs) {
+        const peer = await this.mesh?.connect(url) ?? null;
+        if (peer) {
+            await this.maybeAutoPull(peer);
+            return peer;
+        }
+        // If the first attempt failed with the default timeout, retry once with the
+        // requested longer timeout before giving up.  MeshClient currently uses
+        // opts.timeoutMs for manifest fetches, so we temporarily swap the client.
+        const client = new MeshClient({ token: this.client.token, timeoutMs });
+        const manifest = await client.fetchManifest(url);
+        const viaMesh = await this.mesh?.connect(url) ?? null;
+        if (viaMesh) {
+            await this.maybeAutoPull(viaMesh);
+            return viaMesh;
+        }
+        return null;
+    }
     /** Satellite: pull shared config from a freshly-connected hub/relay. */
     async maybeAutoPull(peer) {
         if (!this.deps.options.autoPullConfig)
@@ -642,7 +663,7 @@ export class Federation {
                 if (this.lanConnecting.has(nodeId))
                     return; // dial in flight
                 this.lanConnecting.add(nodeId);
-                void this.connect(url)
+                void this.connectWithTimeout(url, 30_000)
                     .then(p => {
                     if (p)
                         logger.info(`[federation] lan discovered ${p.displayName ?? name} @ ${url}`);

package/dist/kernel/federation/transport-http.d.ts

@@ -71,6 +71,7 @@ export interface MeshClientOptions {
 export declare class MeshClient {
     private opts;
     constructor(opts?: MeshClientOptions);
+    get token(): string | undefined;
     private headers;
     /** Normalize a base URL so a trailing slash doesn't produce `//fed/...` (→ 404). */
     private base;

package/dist/kernel/federation/transport-http.js

@@ -352,6 +352,9 @@ export class MeshClient {
     constructor(opts = {}) {
         this.opts = opts;
     }
+    get token() {
+        return this.opts.token;
+    }
     headers() {
         const h = { 'content-type': 'application/json' };
         if (this.opts.token)

package/dist/kernel/providers/ollama-provider.d.ts

@@ -30,7 +30,11 @@ export declare class OllamaProvider implements ProviderInterface {
     constructor(options: OllamaProviderOptions);
     capabilities(): Promise<ProviderCapabilities>;
     complete(request: CompletionRequest): Promise<CompletionResult>;
+    private completeNative;
+    private completeOpenAI;
     completeStream(request: CompletionRequest): AsyncIterable<CompletionChunk>;
+    private completeStreamNative;
+    private completeStreamOpenAI;
     refresh(): Promise<void>;
     verify(): Promise<{
         ok: boolean;
@@ -42,6 +46,7 @@ export declare class OllamaProvider implements ProviderInterface {
     private toProviderModel;
     private guessContextLength;
     private buildMessages;
+    private buildPrompt;
     private resolveURL;
     getDefaultModel(): string | undefined;
     getCachedModels(): ProviderModel[];

package/dist/kernel/providers/ollama-provider.js

@@ -35,6 +35,57 @@ export class OllamaProvider {
         };
     }
     async complete(request) {
+        // Local Ollama uses the native /api/generate endpoint.  Some users run an
+        // OpenAI-compatible shim at /v1/chat/completions, but stock Ollama (the
+        // common case in this project) does not, so default to the native protocol
+        // and fall back to the shim only when /api/generate is unavailable.
+        try {
+            return await this.completeNative(request);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (!msg.includes('404'))
+                throw err;
+            return await this.completeOpenAI(request);
+        }
+    }
+    async completeNative(request) {
+        const start = Date.now();
+        const url = await this.resolveURL();
+        const endpoint = `${url}/api/generate`;
+        const body = {
+            model: request.model,
+            prompt: this.buildPrompt(request),
+            system: request.systemPrompt,
+            stream: false,
+            options: {
+                temperature: request.temperature ?? 0.3,
+                num_predict: request.maxTokens ?? 4096,
+            },
+        };
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: this.headers(),
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(this.timeoutMs * 3),
+        });
+        if (!response.ok) {
+            throw new Error(`Ollama completion failed: HTTP ${response.status}`);
+        }
+        const data = (await response.json());
+        const content = data.response ?? '';
+        const tokensIn = data.prompt_eval_count ?? 0;
+        const tokensOut = data.eval_count ?? 0;
+        return {
+            content,
+            providerId: this.info.id,
+            modelId: request.model,
+            tokensIn,
+            tokensOut,
+            durationMs: Date.now() - start,
+        };
+    }
+    async completeOpenAI(request) {
         const start = Date.now();
         const url = await this.resolveURL();
         const endpoint = `${url}/v1/chat/completions`;
@@ -68,6 +119,72 @@ export class OllamaProvider {
         };
     }
     async *completeStream(request) {
+        // Prefer native /api/generate streaming; fall back to OpenAI-compatible shim
+        // only when the native endpoint returns 404.
+        try {
+            yield* this.completeStreamNative(request);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (!msg.includes('404'))
+                throw err;
+            yield* this.completeStreamOpenAI(request);
+        }
+    }
+    async *completeStreamNative(request) {
+        const url = await this.resolveURL();
+        const endpoint = `${url}/api/generate`;
+        const body = {
+            model: request.model,
+            prompt: this.buildPrompt(request),
+            system: request.systemPrompt,
+            stream: true,
+            options: {
+                temperature: request.temperature ?? 0.3,
+                num_predict: request.maxTokens ?? 4096,
+            },
+        };
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: this.headers(),
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(this.timeoutMs * 6),
+        });
+        if (!response.ok || !response.body) {
+            throw new Error(`Ollama stream failed: HTTP ${response.status}`);
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const chunk = JSON.parse(trimmed);
+                    const delta = chunk.response ?? '';
+                    if (delta) {
+                        yield { delta, done: false, providerId: this.info.id, modelId: request.model };
+                    }
+                    if (chunk.done) {
+                        yield { delta: '', done: true, providerId: this.info.id, modelId: request.model };
+                        return;
+                    }
+                }
+                catch {
+                    // skip malformed
+                }
+            }
+        }
+    }
+    async *completeStreamOpenAI(request) {
         const url = await this.resolveURL();
         const endpoint = `${url}/v1/chat/completions`;
         const body = {
@@ -227,6 +344,20 @@ export class OllamaProvider {
         messages.push({ role: 'user', content: request.prompt });
         return messages;
     }
+    buildPrompt(request) {
+        const parts = [];
+        if (request.systemPrompt) {
+            parts.push(request.systemPrompt);
+        }
+        if (request.context) {
+            const ctxStr = Object.entries(request.context)
+                .map(([k, v]) => `${k}: ${typeof v === 'string' ? v : JSON.stringify(v)}`)
+                .join('\n');
+            parts.push(ctxStr);
+        }
+        parts.push(request.prompt);
+        return parts.join('\n\n');
+    }
     async resolveURL() {
         const candidates = [this.activeURL, this.fallbackURL, this.baseURL].filter((u, i, arr) => !!u && arr.indexOf(u) === i);
         for (const candidate of candidates) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinicode",
-  "version": "2.8.26",
+  "version": "2.8.27",
   "description": "OpenKernel — provider-agnostic AI execution kernel. Native coding agent + mission-driven execution runtime.",
   "type": "module",
   "main": "./dist/kernel/index.js",

package/packages/robopark/scheduler/preview_agent.py

@@ -350,6 +350,23 @@ class PreviewAgent:
         return dt.timestamp()
 
     async def _end_vision_session(self) -> None:
+        # Tell the scheduler too, not just the local publisher/LiveKit
+        # connection — otherwise the sessions row never gets ended_at set,
+        # and the server's active_sessions count climbs forever until it
+        # hits max_sessions and silently blocks the room getting genuinely
+        # picked up (unrelated to this specific dispatch, but a real bug:
+        # every silence-timeout before this fix leaked a permanently
+        # "active" session).
+        if self._session and self.device_token:
+            try:
+                await self._session.post(
+                    f"{self.scheduler_url.rstrip('/')}/api/robots/{self.device_id or self.robot_id}/end-session",
+                    params={"reason": "silence"},
+                    headers={"Authorization": f"Bearer {self.device_token}"},
+                    timeout=10.0,
+                )
+            except Exception as e:
+                logger.warning(f"failed to notify scheduler of session end: {e}")
         self._vision_session_id = None
         self._vision_hard_deadline = 0.0
         self._vision_last_activity = 0.0