pretticlaw 0.1.2 → 0.1.3

package/.env.example

@@ -0,0 +1,5 @@
+API_KEY=***
+PROVIDER=openai
+MODEL=gpt-4.1-mini
+TEMPERATURE=0.1
+MAX_TOKENS=8192

package/.github/workflows/main.yml

@@ -0,0 +1,47 @@
+name: Build and Push Docker Image
+
+on:
+  push:
+    branches:
+      - main
+  release:
+    types: [published]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Extract metadata (tags)
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: amitdey13/pretticlaw
+          tags: |
+            type=raw,value=latest
+            type=ref,event=branch
+            type=ref,event=tag
+
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          platforms: linux/amd64,linux/arm64
+          tags: ${{ steps.meta.outputs.tags }}

package/Dockerfile

@@ -0,0 +1,19 @@
+FROM node:20-alpine
+
+# Create app directory
+WORKDIR /app
+
+# Install pretticlaw globally
+RUN npm install -g pretticlaw
+
+# Create pretticlaw home
+RUN mkdir -p /root/.pretticlaw
+
+# Copy entrypoint
+COPY entrypoint.sh /entrypoint.sh
+RUN chmod +x /entrypoint.sh
+
+EXPOSE 18790
+EXPOSE 6767
+
+ENTRYPOINT ["/entrypoint.sh"]

package/dist/cli/commands.js

@@ -54,6 +54,7 @@ const MODEL_CHOICES = {
         "deepseek/deepseek-reasoner",
     ],
     gemini: [
+        "gemini/gemini-3-flash-preview",
         "gemini/gemini-2.5-pro",
         "gemini/gemini-2.5-flash",
     ],
@@ -128,6 +129,7 @@ export function buildProgram() {
                     { title: "OpenAI", value: "openai" },
                     { title: "DeepSeek", value: "deepseek" },
                     { title: "Groq", value: "groq" },
+                    { title: "Gemini", value: "gemini" },
                     { title: "Moonshot", value: "moonshot" },
                     { title: "MiniMax", value: "minimax" },
                     { title: "DashScope", value: "dashscope" },

package/dist/dashboard/index.html

@@ -989,7 +989,7 @@
         anthropic: ["anthropic/claude-opus-4-5","anthropic/claude-sonnet-4"],
         openai: ["gpt-5.2","gpt-5.2-pro","gpt-5.3-codex","gpt-5.2-codex","gpt-5.1","gpt-5.1-codex","gpt-5 mini","gpt-5 nano","gpt-4.1","gpt-4.1 mini","gpt-4.1 nano","gpt-4o","gpt-4o mini"],
         deepseek: ["deepseek/deepseek-chat","deepseek/deepseek-reasoner"],
-        gemini: ["gemini/gemini-2.5-pro","gemini/gemini-2.5-flash"],
+        gemini: ["gemini/gemini-3-flash-preview","gemini/gemini-2.5-pro","gemini/gemini-2.5-flash"],
         moonshot: ["moonshot/kimi-k2.5"],
         minimax: ["minimax/MiniMax-M2.1"],
         dashscope: ["dashscope/qwen-max"],

package/dist/providers/gemini-provider.d.ts

@@ -0,0 +1,20 @@
+import type { LLMProvider, LLMResponse } from "./base.js";
+export declare class GeminiProvider implements LLMProvider {
+    private readonly apiKey;
+    private readonly apiBase;
+    private readonly defaultModel;
+    private static readonly DEFAULT_BASE;
+    constructor(apiKey: string, apiBase: string | null, defaultModel: string);
+    getDefaultModel(): string;
+    resolveModel(model: string): string;
+    private asText;
+    private parseToolArgs;
+    private toGemini;
+    chat(input: {
+        messages: Array<Record<string, unknown>>;
+        tools?: Array<Record<string, unknown>>;
+        model?: string;
+        maxTokens?: number;
+        temperature?: number;
+    }): Promise<LLMResponse>;
+}

package/dist/providers/gemini-provider.js

@@ -0,0 +1,174 @@
+import { nanoid } from "nanoid";
+export class GeminiProvider {
+    apiKey;
+    apiBase;
+    defaultModel;
+    static DEFAULT_BASE = "https://generativelanguage.googleapis.com/v1beta";
+    constructor(apiKey, apiBase, defaultModel) {
+        this.apiKey = apiKey;
+        this.apiBase = apiBase;
+        this.defaultModel = defaultModel;
+    }
+    getDefaultModel() {
+        return this.defaultModel;
+    }
+    resolveModel(model) {
+        let out = model.trim();
+        if (out.includes("/")) {
+            const [prefix, rest] = out.split("/", 2);
+            const norm = prefix.toLowerCase();
+            if (norm === "gemini" || norm === "google")
+                out = rest;
+        }
+        return out.startsWith("models/") ? out.slice("models/".length) : out;
+    }
+    asText(value) {
+        if (typeof value === "string")
+            return value;
+        if (value == null)
+            return "";
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return String(value);
+        }
+    }
+    parseToolArgs(value) {
+        if (value && typeof value === "object" && !Array.isArray(value))
+            return value;
+        if (typeof value === "string") {
+            try {
+                const parsed = JSON.parse(value);
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+                    return parsed;
+            }
+            catch {
+                // ignore invalid json and return empty args
+            }
+        }
+        return {};
+    }
+    toGemini(input) {
+        const systemTexts = [];
+        const contents = [];
+        for (const msg of input.messages) {
+            const role = String(msg.role ?? "");
+            if (role === "system") {
+                const txt = this.asText(msg.content).trim();
+                if (txt)
+                    systemTexts.push(txt);
+                continue;
+            }
+            if (role === "user") {
+                const txt = this.asText(msg.content).trim();
+                if (!txt)
+                    continue;
+                contents.push({ role: "user", parts: [{ text: txt }] });
+                continue;
+            }
+            if (role === "assistant" || role === "model") {
+                const parts = [];
+                const txt = this.asText(msg.content).trim();
+                if (txt)
+                    parts.push({ text: txt });
+                const toolCalls = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+                for (const tc of toolCalls) {
+                    const fn = tc.function;
+                    if (!fn?.name)
+                        continue;
+                    parts.push({ functionCall: { name: fn.name, args: this.parseToolArgs(fn.arguments) } });
+                }
+                if (parts.length)
+                    contents.push({ role: "model", parts });
+                continue;
+            }
+            if (role === "tool") {
+                const name = typeof msg.name === "string" ? msg.name : "";
+                if (!name)
+                    continue;
+                const contentText = this.asText(msg.content);
+                contents.push({
+                    role: "user",
+                    parts: [{ functionResponse: { name, response: { result: contentText } } }],
+                });
+            }
+        }
+        if (!contents.length) {
+            contents.push({ role: "user", parts: [{ text: "Hello" }] });
+        }
+        const out = {
+            contents,
+            generationConfig: {
+                temperature: input.temperature ?? 0.1,
+                maxOutputTokens: Math.max(1, input.maxTokens ?? 4096),
+            },
+        };
+        if (systemTexts.length) {
+            out.systemInstruction = {
+                parts: [{ text: systemTexts.join("\n\n") }],
+            };
+        }
+        const tools = (input.tools ?? [])
+            .map((t) => t)
+            .filter((t) => t.type === "function" && t.function?.name)
+            .map((t) => ({
+            name: t.function.name,
+            description: t.function?.description ?? "",
+            parameters: t.function?.parameters ?? { type: "object", properties: {} },
+        }));
+        if (tools.length) {
+            out.tools = [{ functionDeclarations: tools }];
+            out.toolConfig = { functionCallingConfig: { mode: "AUTO" } };
+        }
+        return out;
+    }
+    async chat(input) {
+        try {
+            const model = this.resolveModel(input.model ?? this.defaultModel);
+            const base = (this.apiBase ?? GeminiProvider.DEFAULT_BASE).replace(/\/$/, "");
+            const url = `${base}/models/${encodeURIComponent(model)}:generateContent`;
+            const body = this.toGemini(input);
+            const res = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-goog-api-key": this.apiKey,
+                },
+                body: JSON.stringify(body),
+            });
+            const json = await res.json();
+            if (!res.ok) {
+                const msg = json?.error?.message ?? JSON.stringify(json);
+                return { content: `Error calling LLM: ${msg}`, toolCalls: [], finishReason: "error", usage: {}, reasoningContent: null };
+            }
+            const candidate = json?.candidates?.[0];
+            const parts = candidate?.content?.parts ?? [];
+            const textParts = parts.filter((p) => typeof p?.text === "string").map((p) => String(p.text));
+            const toolCalls = parts
+                .filter((p) => p?.functionCall?.name)
+                .map((p) => ({
+                id: nanoid(9),
+                name: String(p.functionCall.name),
+                arguments: this.parseToolArgs(p.functionCall.args),
+            }));
+            const usage = {};
+            if (json?.usageMetadata) {
+                usage.prompt_tokens = Number(json.usageMetadata.promptTokenCount ?? 0);
+                usage.completion_tokens = Number(json.usageMetadata.candidatesTokenCount ?? 0);
+                usage.total_tokens = Number(json.usageMetadata.totalTokenCount ?? 0);
+            }
+            const finish = String(candidate?.finishReason ?? "STOP").toLowerCase();
+            return {
+                content: textParts.length ? textParts.join("\n") : null,
+                toolCalls,
+                finishReason: finish,
+                usage,
+                reasoningContent: null,
+            };
+        }
+        catch (err) {
+            return { content: `Error calling LLM: ${String(err)}`, toolCalls: [], finishReason: "error", usage: {}, reasoningContent: null };
+        }
+    }
+}

package/dist/providers/registry.js

@@ -1,5 +1,6 @@
 import { PROVIDERS, getApiBase, getProvider, getProviderName } from "../config/schema.js";
 import { CustomProvider } from "./custom-provider.js";
+import { GeminiProvider } from "./gemini-provider.js";
 import { LiteLLMProvider } from "./litellm-provider.js";
 export function findByModel(model) {
     const lower = model.toLowerCase();
@@ -28,7 +29,7 @@ export function makeProvider(config) {
     const providerName = getProviderName(config, model);
     const p = getProvider(config, model);
     const oauthProviders = new Set(["openai_codex", "github_copilot"]);
-    const unsupportedInTs = new Set(["anthropic", "gemini"]);
+    const unsupportedInTs = new Set(["anthropic"]);
     if (!providerName) {
         throw new Error("No provider could be resolved from config. Run `pretticlaw onboard` and set provider/model/API key.");
     }
@@ -41,5 +42,8 @@ export function makeProvider(config) {
     if (providerName === "custom") {
         return new CustomProvider(p?.apiKey || "no-key", getApiBase(config, model) || "http://localhost:8000/v1", model);
     }
+    if (providerName === "gemini") {
+        return new GeminiProvider(p?.apiKey || "", getApiBase(config, model), model);
+    }
     return new LiteLLMProvider(p?.apiKey ?? null, getApiBase(config, model), model, providerName);
 }

package/docker-compose.yaml

@@ -0,0 +1,20 @@
+services:
+  pretticlaw:
+    build: .
+    container_name: pretticlaw
+    ports:
+      - "18790:18790"
+      - "6767:6767"
+    environment:
+      PROVIDER: ${PROVIDER}
+      MODEL: ${MODEL}
+      API_KEY: ${API_KEY}
+      API_BASE: ${API_BASE}
+      TEMPERATURE: ${TEMPERATURE}
+      MAX_TOKENS: ${MAX_TOKENS}
+    volumes:
+      - pretticlaw_data:/root/.pretticlaw
+    restart: unless-stopped
+
+volumes:
+  pretticlaw_data:

package/entrypoint.sh

@@ -0,0 +1,50 @@
+#!/bin/sh
+set -e
+
+CONFIG_DIR="/root/.pretticlaw"
+CONFIG_FILE="$CONFIG_DIR/config.json"
+
+mkdir -p $CONFIG_DIR/workspace
+
+PROVIDER=${PROVIDER:-openai}
+MODEL=${MODEL:-gpt-4.1-mini}
+API_KEY=${API_KEY}
+API_BASE=${API_BASE:-null}
+TEMPERATURE=${TEMPERATURE:-0.1}
+MAX_TOKENS=${MAX_TOKENS:-8192}
+
+if [ -z "$API_KEY" ]; then
+  echo "ERROR: API_KEY is required"
+  exit 1
+fi
+
+if [ ! -f "$CONFIG_FILE" ]; then
+  echo "Generating config for provider: $PROVIDER"
+
+  cat <<EOF > $CONFIG_FILE
+{
+  "agents": {
+    "defaults": {
+      "workspace": "/root/.pretticlaw/workspace",
+      "model": "$MODEL",
+      "provider": "$PROVIDER",
+      "maxTokens": $MAX_TOKENS,
+      "temperature": $TEMPERATURE
+    }
+  },
+  "providers": {
+    "$PROVIDER": {
+      "apiKey": "$API_KEY",
+      "apiBase": $API_BASE
+    }
+  },
+  "gateway": {
+    "host": "0.0.0.0",
+    "port": 18790
+  }
+}
+EOF
+fi
+
+echo "Starting Pretticlaw Gateway..."
+pretticlaw gateway

package/line_count.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+# Count all lines in all files under src/ (recursively)
+cd "$(dirname "$0")" || exit 1
+
+echo "pretticlaw src/ line count"
+echo "================================"
+echo ""
+
+total=$(find src -type f -exec cat {} + | wc -l)
+echo "  Total lines in src/: $total"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pretticlaw",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Lightweight AI Assistant That Lives in Your Computer",
   "type": "module",
   "main": "dist/index.js",

package/src/cli/commands.ts

@@ -64,6 +64,7 @@ openai: [
   ],
  
   gemini: [
+    "gemini/gemini-3-flash-preview",
     "gemini/gemini-2.5-pro",
     "gemini/gemini-2.5-flash",
   ],
@@ -141,6 +142,7 @@ export function buildProgram(): Command {
           { title: "OpenAI", value: "openai" },
           { title: "DeepSeek", value: "deepseek" },
           { title: "Groq", value: "groq" },
+          { title: "Gemini", value: "gemini" },
           { title: "Moonshot", value: "moonshot" },
           { title: "MiniMax", value: "minimax" },
           { title: "DashScope", value: "dashscope" },

package/src/dashboard/index.html

@@ -989,7 +989,7 @@
         anthropic: ["anthropic/claude-opus-4-5","anthropic/claude-sonnet-4"],
         openai: ["gpt-5.2","gpt-5.2-pro","gpt-5.3-codex","gpt-5.2-codex","gpt-5.1","gpt-5.1-codex","gpt-5 mini","gpt-5 nano","gpt-4.1","gpt-4.1 mini","gpt-4.1 nano","gpt-4o","gpt-4o mini"],
         deepseek: ["deepseek/deepseek-chat","deepseek/deepseek-reasoner"],
-        gemini: ["gemini/gemini-2.5-pro","gemini/gemini-2.5-flash"],
+        gemini: ["gemini/gemini-3-flash-preview","gemini/gemini-2.5-pro","gemini/gemini-2.5-flash"],
         moonshot: ["moonshot/kimi-k2.5"],
         minimax: ["minimax/MiniMax-M2.1"],
         dashscope: ["dashscope/qwen-max"],

package/src/providers/gemini-provider.ts

@@ -0,0 +1,216 @@
+import { nanoid } from "nanoid";
+import type { LLMProvider, LLMResponse, ToolCallRequest } from "./base.js";
+
+type OpenAITool = {
+  type?: string;
+  function?: {
+    name?: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+  };
+};
+
+type GeminiPart =
+  | { text: string }
+  | { functionCall: { name: string; args?: Record<string, unknown> } }
+  | { functionResponse: { name: string; response: Record<string, unknown> } };
+
+type GeminiContent = {
+  role: "user" | "model";
+  parts: GeminiPart[];
+};
+
+export class GeminiProvider implements LLMProvider {
+  private static readonly DEFAULT_BASE = "https://generativelanguage.googleapis.com/v1beta";
+
+  constructor(
+    private readonly apiKey: string,
+    private readonly apiBase: string | null,
+    private readonly defaultModel: string,
+  ) {}
+
+  getDefaultModel(): string {
+    return this.defaultModel;
+  }
+
+  resolveModel(model: string): string {
+    let out = model.trim();
+    if (out.includes("/")) {
+      const [prefix, rest] = out.split("/", 2);
+      const norm = prefix.toLowerCase();
+      if (norm === "gemini" || norm === "google") out = rest;
+    }
+    return out.startsWith("models/") ? out.slice("models/".length) : out;
+  }
+
+  private asText(value: unknown): string {
+    if (typeof value === "string") return value;
+    if (value == null) return "";
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+
+  private parseToolArgs(value: unknown): Record<string, unknown> {
+    if (value && typeof value === "object" && !Array.isArray(value)) return value as Record<string, unknown>;
+    if (typeof value === "string") {
+      try {
+        const parsed = JSON.parse(value);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed as Record<string, unknown>;
+      } catch {
+        // ignore invalid json and return empty args
+      }
+    }
+    return {};
+  }
+
+  private toGemini(input: { messages: Array<Record<string, unknown>>; tools?: Array<Record<string, unknown>>; temperature?: number; maxTokens?: number }): {
+    systemInstruction?: { parts: Array<{ text: string }> };
+    contents: GeminiContent[];
+    tools?: Array<{ functionDeclarations: Array<Record<string, unknown>> }>;
+    toolConfig?: { functionCallingConfig: { mode: "AUTO" } };
+    generationConfig: { temperature: number; maxOutputTokens: number };
+  } {
+    const systemTexts: string[] = [];
+    const contents: GeminiContent[] = [];
+
+    for (const msg of input.messages) {
+      const role = String(msg.role ?? "");
+
+      if (role === "system") {
+        const txt = this.asText(msg.content).trim();
+        if (txt) systemTexts.push(txt);
+        continue;
+      }
+
+      if (role === "user") {
+        const txt = this.asText(msg.content).trim();
+        if (!txt) continue;
+        contents.push({ role: "user", parts: [{ text: txt }] });
+        continue;
+      }
+
+      if (role === "assistant" || role === "model") {
+        const parts: GeminiPart[] = [];
+        const txt = this.asText(msg.content).trim();
+        if (txt) parts.push({ text: txt });
+
+        const toolCalls = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+        for (const tc of toolCalls) {
+          const fn = (tc as { function?: { name?: string; arguments?: unknown } }).function;
+          if (!fn?.name) continue;
+          parts.push({ functionCall: { name: fn.name, args: this.parseToolArgs(fn.arguments) } });
+        }
+
+        if (parts.length) contents.push({ role: "model", parts });
+        continue;
+      }
+
+      if (role === "tool") {
+        const name = typeof msg.name === "string" ? msg.name : "";
+        if (!name) continue;
+        const contentText = this.asText(msg.content);
+        contents.push({
+          role: "user",
+          parts: [{ functionResponse: { name, response: { result: contentText } } }],
+        });
+      }
+    }
+
+    if (!contents.length) {
+      contents.push({ role: "user", parts: [{ text: "Hello" }] });
+    }
+
+    const out: {
+      systemInstruction?: { parts: Array<{ text: string }> };
+      contents: GeminiContent[];
+      tools?: Array<{ functionDeclarations: Array<Record<string, unknown>> }>;
+      toolConfig?: { functionCallingConfig: { mode: "AUTO" } };
+      generationConfig: { temperature: number; maxOutputTokens: number };
+    } = {
+      contents,
+      generationConfig: {
+        temperature: input.temperature ?? 0.1,
+        maxOutputTokens: Math.max(1, input.maxTokens ?? 4096),
+      },
+    };
+
+    if (systemTexts.length) {
+      out.systemInstruction = {
+        parts: [{ text: systemTexts.join("\n\n") }],
+      };
+    }
+
+    const tools = (input.tools ?? [])
+      .map((t) => t as OpenAITool)
+      .filter((t) => t.type === "function" && t.function?.name)
+      .map((t) => ({
+        name: t.function!.name!,
+        description: t.function?.description ?? "",
+        parameters: t.function?.parameters ?? { type: "object", properties: {} },
+      }));
+
+    if (tools.length) {
+      out.tools = [{ functionDeclarations: tools }];
+      out.toolConfig = { functionCallingConfig: { mode: "AUTO" } };
+    }
+
+    return out;
+  }
+
+  async chat(input: { messages: Array<Record<string, unknown>>; tools?: Array<Record<string, unknown>>; model?: string; maxTokens?: number; temperature?: number }): Promise<LLMResponse> {
+    try {
+      const model = this.resolveModel(input.model ?? this.defaultModel);
+      const base = (this.apiBase ?? GeminiProvider.DEFAULT_BASE).replace(/\/$/, "");
+      const url = `${base}/models/${encodeURIComponent(model)}:generateContent`;
+      const body = this.toGemini(input);
+
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-goog-api-key": this.apiKey,
+        },
+        body: JSON.stringify(body),
+      });
+
+      const json: any = await res.json();
+      if (!res.ok) {
+        const msg = json?.error?.message ?? JSON.stringify(json);
+        return { content: `Error calling LLM: ${msg}`, toolCalls: [], finishReason: "error", usage: {}, reasoningContent: null };
+      }
+
+      const candidate = json?.candidates?.[0];
+      const parts: any[] = candidate?.content?.parts ?? [];
+      const textParts = parts.filter((p) => typeof p?.text === "string").map((p) => String(p.text));
+      const toolCalls: ToolCallRequest[] = parts
+        .filter((p) => p?.functionCall?.name)
+        .map((p) => ({
+          id: nanoid(9),
+          name: String(p.functionCall.name),
+          arguments: this.parseToolArgs(p.functionCall.args),
+        }));
+
+      const usage: Record<string, number> = {};
+      if (json?.usageMetadata) {
+        usage.prompt_tokens = Number(json.usageMetadata.promptTokenCount ?? 0);
+        usage.completion_tokens = Number(json.usageMetadata.candidatesTokenCount ?? 0);
+        usage.total_tokens = Number(json.usageMetadata.totalTokenCount ?? 0);
+      }
+
+      const finish = String(candidate?.finishReason ?? "STOP").toLowerCase();
+
+      return {
+        content: textParts.length ? textParts.join("\n") : null,
+        toolCalls,
+        finishReason: finish,
+        usage,
+        reasoningContent: null,
+      };
+    } catch (err) {
+      return { content: `Error calling LLM: ${String(err)}`, toolCalls: [], finishReason: "error", usage: {}, reasoningContent: null };
+    }
+  }
+}

package/src/providers/registry.ts

@@ -1,6 +1,7 @@
 import { PROVIDERS, type Config, getApiBase, getProvider, getProviderName } from "../config/schema.js";
 import type { LLMProvider } from "./base.js";
 import { CustomProvider } from "./custom-provider.js";
+import { GeminiProvider } from "./gemini-provider.js";
 import { LiteLLMProvider } from "./litellm-provider.js";
 
 export function findByModel(model: string): (typeof PROVIDERS)[number] | null {
@@ -29,7 +30,7 @@ export function makeProvider(config: Config): LLMProvider {
   const p = getProvider(config, model);
 
   const oauthProviders = new Set(["openai_codex", "github_copilot"]);
-  const unsupportedInTs = new Set(["anthropic", "gemini"]);
+  const unsupportedInTs = new Set(["anthropic"]);
   if (!providerName) {
     throw new Error("No provider could be resolved from config. Run `pretticlaw onboard` and set provider/model/API key.");
   }
@@ -43,6 +44,9 @@ export function makeProvider(config: Config): LLMProvider {
   if (providerName === "custom") {
     return new CustomProvider(p?.apiKey || "no-key", getApiBase(config, model) || "http://localhost:8000/v1", model);
   }
+  if (providerName === "gemini") {
+    return new GeminiProvider(p?.apiKey || "", getApiBase(config, model), model);
+  }
 
   return new LiteLLMProvider(p?.apiKey ?? null, getApiBase(config, model), model, providerName);
-}
+}

package/test/providers.test.ts

@@ -3,6 +3,8 @@ import { DEFAULT_CONFIG, getProviderName } from "../src/config/schema.js";
 import { findByModel } from "../src/providers/registry.js";
 import { LiteLLMProvider } from "../src/providers/litellm-provider.js";
 import { stripModelPrefix } from "../src/providers/registry.js";
+import { makeProvider } from "../src/providers/registry.js";
+import { GeminiProvider } from "../src/providers/gemini-provider.js";
 
 describe("provider matching", () => {
   test("matches github copilot with hyphen prefix", () => {
@@ -40,4 +42,13 @@ describe("provider matching", () => {
     expect(stripModelPrefix("openai-codex/gpt-5.1-codex")).toBe("gpt-5.1-codex");
     expect(stripModelPrefix("openai_codex/gpt-5.1-codex")).toBe("gpt-5.1-codex");
   });
-});
+
+  test("creates native gemini provider", () => {
+    const config = structuredClone(DEFAULT_CONFIG);
+    config.agents.defaults.provider = "gemini";
+    config.agents.defaults.model = "gemini/gemini-3-flash-preview";
+    config.providers.gemini.apiKey = "test-key";
+    const provider = makeProvider(config);
+    expect(provider).toBeInstanceOf(GeminiProvider);
+  });
+});