@k2wanko/gemini-cli-sdk 0.1.2 → 0.2.1

package/dist/agent.d.ts

@@ -10,15 +10,26 @@ export interface GeminiAgentOptions {
     model?: string;
     cwd?: string;
     debug?: boolean;
+    /** Resume a specific session by ID */
+    sessionId?: string;
+    /** Context compression threshold (0-1 fraction) */
+    compressionThreshold?: number;
 }
 export declare class GeminiAgent {
     private readonly config;
     private readonly tools;
     private readonly skillRefs;
     private readonly instructions;
+    private readonly resumeSessionId;
     private instructionsLoaded;
     constructor(options: GeminiAgentOptions);
+    /** Return the session ID assigned to this agent instance */
+    getSessionId(): string;
+    /** List available sessions for the current project */
+    listSessions(): Promise<import("./session.js").SessionInfo[]>;
     sendStream(prompt: string, signal?: AbortSignal): AsyncGenerator<ServerGeminiStreamEvent>;
+    private initialized;
+    private ensureInitialized;
     private initialize;
     private resolveInstructions;
     private buildScopedRegistry;

package/dist/agent.js

@@ -1,5 +1,6 @@
 import { ActivateSkillTool, AuthType, Config, GeminiEventType, getAuthTypeFromEnv, loadSkillsFromDir, PolicyDecision, PREVIEW_GEMINI_MODEL_AUTO, scheduleAgentTools, } from "@google/gemini-cli-core";
 import { AgentFsImpl, AgentShellImpl } from "./context.js";
+import { listSessions, loadSession, messageRecordsToHistory, } from "./session.js";
 import { SdkTool } from "./tool.js";
 export { GeminiEventType };
 export class GeminiAgent {
@@ -7,11 +8,13 @@ export class GeminiAgent {
     tools;
     skillRefs;
     instructions;
+    resumeSessionId;
     instructionsLoaded = false;
     constructor(options) {
         this.instructions = options.instructions;
         this.tools = options.tools ?? [];
         this.skillRefs = options.skills ?? [];
+        this.resumeSessionId = options.sessionId;
         const cwd = options.cwd ?? process.cwd();
         const initialMemory = typeof this.instructions === "string" ? this.instructions : "";
         const configParams = {
@@ -29,9 +32,19 @@ export class GeminiAgent {
             policyEngineConfig: {
                 defaultDecision: PolicyDecision.ALLOW,
             },
+            compressionThreshold: options.compressionThreshold,
         };
         this.config = new Config(configParams);
     }
+    /** Return the session ID assigned to this agent instance */
+    getSessionId() {
+        return this.config.getSessionId();
+    }
+    /** List available sessions for the current project */
+    async listSessions() {
+        await this.ensureInitialized();
+        return listSessions(this.config);
+    }
     async *sendStream(prompt, signal) {
         await this.initialize();
         const client = this.config.getGeminiClient();
@@ -87,12 +100,30 @@ export class GeminiAgent {
     // -------------------------------------------------------------------------
     // Private helpers
     // -------------------------------------------------------------------------
-    async initialize() {
-        if (this.config.getContentGenerator())
+    initialized = false;
+    async ensureInitialized() {
+        if (this.initialized)
             return;
         const authType = getAuthTypeFromEnv() || AuthType.COMPUTE_ADC;
         await this.config.refreshAuth(authType);
         await this.config.initialize();
+        this.initialized = true;
+    }
+    async initialize() {
+        if (this.config.getContentGenerator())
+            return;
+        await this.ensureInitialized();
+        // Resume previous session if requested
+        if (this.resumeSessionId) {
+            const sessions = await listSessions(this.config);
+            const target = sessions.find((s) => s.sessionId === this.resumeSessionId);
+            if (target) {
+                const resumed = await loadSession(target.filePath);
+                const history = messageRecordsToHistory(resumed.conversation.messages);
+                const client = this.config.getGeminiClient();
+                await client.resumeChat(history, resumed);
+            }
+        }
         // Load skills from directories
         if (this.skillRefs.length > 0) {
             const skillManager = this.config.getSkillManager();

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./agent.js";
 export * from "./context.js";
+export * from "./session.js";
 export * from "./skills.js";
 export * from "./tool.js";

package/dist/index.js

@@ -1,4 +1,5 @@
 export * from "./agent.js";
 export * from "./context.js";
+export * from "./session.js";
 export * from "./skills.js";
 export * from "./tool.js";

package/dist/session.d.ts

@@ -0,0 +1,17 @@
+import { type ConversationRecord, type Config as CoreConfig, type MessageRecord, type ResumedSessionData } from "@google/gemini-cli-core";
+import type { Content } from "@google/genai";
+export type { ConversationRecord, MessageRecord, ResumedSessionData };
+export interface SessionInfo {
+    sessionId: string;
+    filePath: string;
+    startTime: string;
+    lastUpdated: string;
+    messageCount: number;
+    summary?: string;
+}
+/** List available sessions for the current project */
+export declare function listSessions(config: CoreConfig): Promise<SessionInfo[]>;
+/** Load a session file into ResumedSessionData */
+export declare function loadSession(filePath: string): Promise<ResumedSessionData>;
+/** Convert MessageRecord[] to Content[] for API history reconstruction */
+export declare function messageRecordsToHistory(messages: MessageRecord[]): Content[];

package/dist/session.js

@@ -0,0 +1,95 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { SESSION_FILE_PREFIX, } from "@google/gemini-cli-core";
+/** List available sessions for the current project */
+export async function listSessions(config) {
+    const chatsDir = path.join(config.storage.getProjectTempDir(), "chats");
+    let files;
+    try {
+        files = await fs.readdir(chatsDir);
+    }
+    catch {
+        return [];
+    }
+    const sessionFiles = files
+        .filter((f) => f.startsWith(SESSION_FILE_PREFIX) && f.endsWith(".json"))
+        .sort((a, b) => b.localeCompare(a)); // newest first
+    const sessions = [];
+    for (const file of sessionFiles) {
+        try {
+            const filePath = path.join(chatsDir, file);
+            const raw = await fs.readFile(filePath, "utf-8");
+            const conv = JSON.parse(raw);
+            sessions.push({
+                sessionId: conv.sessionId,
+                filePath,
+                startTime: conv.startTime,
+                lastUpdated: conv.lastUpdated,
+                messageCount: conv.messages.length,
+                summary: conv.summary,
+            });
+        }
+        catch {
+            /* skip corrupted files */
+        }
+    }
+    return sessions;
+}
+/** Load a session file into ResumedSessionData */
+export async function loadSession(filePath) {
+    const raw = await fs.readFile(filePath, "utf-8");
+    const conversation = JSON.parse(raw);
+    return { conversation, filePath };
+}
+/** Convert MessageRecord[] to Content[] for API history reconstruction */
+export function messageRecordsToHistory(messages) {
+    const history = [];
+    for (const msg of messages) {
+        if (msg.type === "info" || msg.type === "error" || msg.type === "warning") {
+            continue;
+        }
+        if (msg.type === "user") {
+            const parts = normalizeParts(msg.content);
+            if (parts.length > 0)
+                history.push({ role: "user", parts });
+        }
+        if (msg.type === "gemini") {
+            const modelParts = [];
+            const contentParts = normalizeParts(msg.content);
+            modelParts.push(...contentParts);
+            if (msg.toolCalls) {
+                for (const tc of msg.toolCalls) {
+                    modelParts.push({
+                        functionCall: { id: tc.id, name: tc.name, args: tc.args },
+                    });
+                }
+            }
+            if (modelParts.length > 0) {
+                history.push({ role: "model", parts: modelParts });
+            }
+            // Function response parts (user role)
+            if (msg.toolCalls?.some((tc) => tc.result != null)) {
+                const responseParts = [];
+                for (const tc of msg.toolCalls) {
+                    if (tc.result != null) {
+                        responseParts.push(...normalizeParts(tc.result));
+                    }
+                }
+                if (responseParts.length > 0) {
+                    history.push({ role: "user", parts: responseParts });
+                }
+            }
+        }
+    }
+    return history;
+}
+function normalizeParts(content) {
+    if (!content)
+        return [];
+    if (typeof content === "string")
+        return [{ text: content }];
+    if (Array.isArray(content)) {
+        return content.map((item) => typeof item === "string" ? { text: item } : item);
+    }
+    return [content];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k2wanko/gemini-cli-sdk",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "A lightweight SDK for building non-interactive AI agents powered by Google Gemini",
   "type": "module",
   "private": false,