@shareai-lab/kode-sdk 2.7.1 → 2.7.2

package/dist/infra/providers/gemini.js

@@ -0,0 +1,493 @@
+"use strict";
+/**
+ * Gemini Provider Adapter
+ *
+ * Converts internal Anthropic-style messages to Gemini API format.
+ * Supports:
+ * - Thinking with thinkingBudget (2.5 models) or thinkingLevel (3.x models)
+ * - Files API with GCS URIs
+ * - Streaming with SSE
+ * - Function calling
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiProvider = void 0;
+const utils_1 = require("./utils");
+class GeminiProvider {
+    constructor(apiKey, model = 'gemini-3.0-flash', baseUrl = 'https://generativelanguage.googleapis.com/v1beta', proxyUrl, options) {
+        this.apiKey = apiKey;
+        this.maxWindowSize = 1000000;
+        this.maxOutputTokens = 4096;
+        this.temperature = 0.7;
+        this.model = model;
+        this.baseUrl = (0, utils_1.normalizeGeminiBaseUrl)(baseUrl);
+        this.dispatcher = (0, utils_1.getProxyDispatcher)(proxyUrl);
+        this.reasoningTransport = options?.reasoningTransport ?? 'text';
+        this.extraHeaders = options?.extraHeaders;
+        this.extraBody = options?.extraBody;
+        this.providerOptions = options?.providerOptions;
+        this.multimodal = options?.multimodal;
+        this.thinking = options?.thinking;
+    }
+    async uploadFile(input) {
+        if (input.kind !== 'file') {
+            return null;
+        }
+        const url = new URL(`${this.baseUrl}/files`);
+        url.searchParams.set('key', this.apiKey);
+        const body = {
+            file: {
+                display_name: input.filename || 'file.pdf',
+                mime_type: input.mimeType,
+            },
+            content: input.data.toString('base64'),
+        };
+        const response = await fetch(url.toString(), (0, utils_1.withProxy)({
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(this.extraHeaders || {}),
+            },
+            body: JSON.stringify(body),
+        }, this.dispatcher));
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Gemini file upload error: ${response.status} ${error}`);
+        }
+        const data = await response.json();
+        const fileUri = data?.file?.uri ?? data?.uri ?? data?.file_uri;
+        if (!fileUri) {
+            return null;
+        }
+        return { fileUri };
+    }
+    async complete(messages, opts) {
+        const body = {
+            ...(this.extraBody || {}),
+            ...this.buildGeminiRequestBody(messages, {
+                system: opts?.system,
+                tools: opts?.tools,
+                maxTokens: opts?.maxTokens ?? this.maxOutputTokens,
+                temperature: opts?.temperature ?? this.temperature,
+                reasoningTransport: this.reasoningTransport,
+                thinking: opts?.thinking ?? this.thinking,
+            }),
+        };
+        const url = this.buildGeminiUrl('generateContent');
+        const response = await fetch(url.toString(), (0, utils_1.withProxy)({
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(this.extraHeaders || {}),
+            },
+            body: JSON.stringify(body),
+        }, this.dispatcher));
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Gemini API error: ${response.status} ${error}`);
+        }
+        const data = await response.json();
+        const candidate = data?.candidates?.[0];
+        const contentBlocks = (0, utils_1.normalizeThinkBlocks)(this.extractGeminiContentBlocks(candidate?.content), this.reasoningTransport);
+        const usage = data?.usageMetadata;
+        return {
+            role: 'assistant',
+            content: contentBlocks,
+            usage: usage
+                ? {
+                    input_tokens: usage.promptTokenCount ?? 0,
+                    output_tokens: usage.candidatesTokenCount ?? 0,
+                }
+                : undefined,
+            stop_reason: candidate?.finishReason,
+        };
+    }
+    async *stream(messages, opts) {
+        const body = {
+            ...(this.extraBody || {}),
+            ...this.buildGeminiRequestBody(messages, {
+                system: opts?.system,
+                tools: opts?.tools,
+                maxTokens: opts?.maxTokens ?? this.maxOutputTokens,
+                temperature: opts?.temperature ?? this.temperature,
+                reasoningTransport: this.reasoningTransport,
+                thinking: opts?.thinking ?? this.thinking,
+            }),
+        };
+        const url = this.buildGeminiUrl('streamGenerateContent');
+        const response = await fetch(url.toString(), (0, utils_1.withProxy)({
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(this.extraHeaders || {}),
+            },
+            body: JSON.stringify(body),
+        }, this.dispatcher));
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Gemini API error: ${response.status} ${error}`);
+        }
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error('No response body');
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let textStarted = false;
+        const textIndex = 0;
+        let toolIndex = 1;
+        const toolCalls = [];
+        let lastUsage;
+        let collectAll = false;
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            const chunk = decoder.decode(value, { stream: true });
+            if (collectAll) {
+                buffer += chunk;
+                continue;
+            }
+            buffer += chunk;
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (let i = 0; i < lines.length; i++) {
+                let trimmed = lines[i].trim();
+                if (!trimmed)
+                    continue;
+                if (trimmed.startsWith('event:') || trimmed.startsWith(':'))
+                    continue;
+                if (trimmed.startsWith('data:')) {
+                    trimmed = trimmed.slice(5).trim();
+                }
+                if (!trimmed || trimmed === '[DONE]')
+                    continue;
+                if (trimmed.startsWith('[')) {
+                    collectAll = true;
+                    buffer = [trimmed, ...lines.slice(i + 1), buffer].filter(Boolean).join('\n');
+                    break;
+                }
+                let event;
+                try {
+                    event = JSON.parse(trimmed);
+                }
+                catch {
+                    collectAll = true;
+                    buffer = [trimmed, ...lines.slice(i + 1), buffer].filter(Boolean).join('\n');
+                    break;
+                }
+                const { textChunks, functionCalls, usage } = this.parseGeminiChunk(event);
+                if (usage) {
+                    lastUsage = usage;
+                }
+                for (const text of textChunks) {
+                    if (!textStarted) {
+                        textStarted = true;
+                        yield {
+                            type: 'content_block_start',
+                            index: textIndex,
+                            content_block: { type: 'text', text: '' },
+                        };
+                    }
+                    yield {
+                        type: 'content_block_delta',
+                        index: textIndex,
+                        delta: { type: 'text_delta', text },
+                    };
+                }
+                for (const call of functionCalls) {
+                    toolCalls.push(call);
+                }
+            }
+        }
+        if (buffer.trim()) {
+            try {
+                const parsed = JSON.parse(buffer.trim());
+                const events = Array.isArray(parsed) ? parsed : [parsed];
+                for (const event of events) {
+                    const { textChunks, functionCalls, usage } = this.parseGeminiChunk(event);
+                    if (usage) {
+                        lastUsage = usage;
+                    }
+                    for (const text of textChunks) {
+                        if (!textStarted) {
+                            textStarted = true;
+                            yield {
+                                type: 'content_block_start',
+                                index: textIndex,
+                                content_block: { type: 'text', text: '' },
+                            };
+                        }
+                        yield {
+                            type: 'content_block_delta',
+                            index: textIndex,
+                            delta: { type: 'text_delta', text },
+                        };
+                    }
+                    for (const call of functionCalls) {
+                        toolCalls.push(call);
+                    }
+                }
+            }
+            catch {
+                // ignore trailing buffer
+            }
+        }
+        if (textStarted) {
+            yield { type: 'content_block_stop', index: textIndex };
+        }
+        for (const call of toolCalls) {
+            const id = `toolcall-${Date.now()}-${toolIndex}`;
+            const meta = call.thoughtSignature ? { thought_signature: call.thoughtSignature } : undefined;
+            yield {
+                type: 'content_block_start',
+                index: toolIndex,
+                content_block: { type: 'tool_use', id, name: call.name, input: {}, ...(meta ? { meta } : {}) },
+            };
+            yield {
+                type: 'content_block_delta',
+                index: toolIndex,
+                delta: { type: 'input_json_delta', partial_json: (0, utils_1.safeJsonStringify)(call.args) },
+            };
+            yield { type: 'content_block_stop', index: toolIndex };
+            toolIndex += 1;
+        }
+        if (lastUsage) {
+            yield {
+                type: 'message_delta',
+                usage: {
+                    input_tokens: lastUsage.input,
+                    output_tokens: lastUsage.output,
+                },
+            };
+        }
+    }
+    toConfig() {
+        return {
+            provider: 'gemini',
+            model: this.model,
+            baseUrl: this.baseUrl,
+            apiKey: this.apiKey,
+            maxTokens: this.maxOutputTokens,
+            temperature: this.temperature,
+            reasoningTransport: this.reasoningTransport,
+            extraHeaders: this.extraHeaders,
+            extraBody: this.extraBody,
+            providerOptions: this.providerOptions,
+            multimodal: this.multimodal,
+            thinking: this.thinking,
+        };
+    }
+    buildGeminiUrl(action) {
+        const url = new URL(`${this.baseUrl.replace(/\/+$/, '')}/models/${this.model}:${action}`);
+        url.searchParams.set('key', this.apiKey);
+        if (action === 'streamGenerateContent') {
+            url.searchParams.set('alt', 'sse');
+        }
+        return url;
+    }
+    buildGeminiRequestBody(messages, opts) {
+        const systemInstruction = this.buildGeminiSystemInstruction(messages, opts.system, opts.reasoningTransport);
+        const contents = this.buildGeminiContents(messages, opts.reasoningTransport);
+        const tools = opts.tools && opts.tools.length > 0 ? this.buildGeminiTools(opts.tools) : undefined;
+        const generationConfig = {};
+        if (opts.temperature !== undefined)
+            generationConfig.temperature = opts.temperature;
+        if (opts.maxTokens !== undefined)
+            generationConfig.maxOutputTokens = opts.maxTokens;
+        if (opts.thinking?.budgetTokens) {
+            generationConfig.thinkingConfig = { thinkingBudget: opts.thinking.budgetTokens };
+        }
+        else if (opts.thinking?.level) {
+            generationConfig.thinkingConfig = { thinkingLevel: opts.thinking.level.toUpperCase() };
+        }
+        const body = {
+            contents,
+        };
+        if (systemInstruction) {
+            body.systemInstruction = { parts: [{ text: systemInstruction }] };
+        }
+        if (tools) {
+            body.tools = tools;
+        }
+        if (Object.keys(generationConfig).length > 0) {
+            body.generationConfig = generationConfig;
+        }
+        return body;
+    }
+    buildGeminiSystemInstruction(messages, system, reasoningTransport = 'text') {
+        const parts = [];
+        if (system)
+            parts.push(system);
+        for (const msg of messages) {
+            if (msg.role !== 'system')
+                continue;
+            const text = (0, utils_1.concatTextWithReasoning)((0, utils_1.getMessageBlocks)(msg), reasoningTransport);
+            if (text)
+                parts.push(text);
+        }
+        if (parts.length === 0)
+            return undefined;
+        return parts.join('\n\n---\n\n');
+    }
+    buildGeminiContents(messages, reasoningTransport = 'text') {
+        const contents = [];
+        const toolNameById = new Map();
+        const toolSignatureById = new Map();
+        for (const msg of messages) {
+            for (const block of (0, utils_1.getMessageBlocks)(msg)) {
+                if (block.type === 'tool_use') {
+                    toolNameById.set(block.id, block.name);
+                    const signature = block.meta?.thought_signature ?? block.meta?.thoughtSignature;
+                    if (typeof signature === 'string' && signature.length > 0) {
+                        toolSignatureById.set(block.id, signature);
+                    }
+                }
+            }
+        }
+        for (const msg of messages) {
+            if (msg.role === 'system')
+                continue;
+            const role = msg.role === 'assistant' ? 'model' : 'user';
+            const parts = [];
+            let degraded = false;
+            const blocks = (0, utils_1.getMessageBlocks)(msg);
+            for (const block of blocks) {
+                if (block.type === 'text') {
+                    if (block.text)
+                        parts.push({ text: block.text });
+                }
+                else if (block.type === 'reasoning') {
+                    if (reasoningTransport === 'text') {
+                        const text = `<think>${block.reasoning}</think>`;
+                        parts.push({ text });
+                    }
+                }
+                else if (block.type === 'image') {
+                    const imagePart = (0, utils_1.buildGeminiImagePart)(block);
+                    if (imagePart) {
+                        parts.push(imagePart);
+                    }
+                    else {
+                        degraded = true;
+                        parts.push({ text: utils_1.IMAGE_UNSUPPORTED_TEXT });
+                    }
+                }
+                else if (block.type === 'audio') {
+                    degraded = true;
+                    parts.push({ text: utils_1.AUDIO_UNSUPPORTED_TEXT });
+                }
+                else if (block.type === 'file') {
+                    const filePart = (0, utils_1.buildGeminiFilePart)(block);
+                    if (filePart) {
+                        parts.push(filePart);
+                    }
+                    else {
+                        degraded = true;
+                        parts.push({ text: utils_1.FILE_UNSUPPORTED_TEXT });
+                    }
+                }
+                else if (block.type === 'tool_use') {
+                    const part = {
+                        functionCall: {
+                            name: block.name,
+                            args: this.normalizeGeminiArgs(block.input),
+                        },
+                    };
+                    const signature = toolSignatureById.get(block.id);
+                    if (signature) {
+                        part.thoughtSignature = signature;
+                    }
+                    parts.push(part);
+                }
+                else if (block.type === 'tool_result') {
+                    const toolName = toolNameById.get(block.tool_use_id) ?? 'tool';
+                    parts.push({
+                        functionResponse: {
+                            name: toolName,
+                            response: { content: this.formatGeminiToolResult(block.content) },
+                        },
+                    });
+                }
+            }
+            if (degraded) {
+                (0, utils_1.markTransportIfDegraded)(msg, blocks);
+            }
+            if (parts.length > 0) {
+                contents.push({ role, parts });
+            }
+        }
+        return contents;
+    }
+    buildGeminiTools(tools) {
+        return [
+            {
+                functionDeclarations: tools.map((tool) => ({
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: (0, utils_1.sanitizeGeminiSchema)(tool.input_schema),
+                })),
+            },
+        ];
+    }
+    normalizeGeminiArgs(input) {
+        if (input && typeof input === 'object' && !Array.isArray(input)) {
+            return input;
+        }
+        return { value: input };
+    }
+    formatGeminiToolResult(content) {
+        if (typeof content === 'string')
+            return content;
+        return (0, utils_1.safeJsonStringify)(content);
+    }
+    extractGeminiContentBlocks(content) {
+        const blocks = [];
+        const parts = content?.parts ?? [];
+        for (const part of parts) {
+            if (typeof part?.text === 'string') {
+                blocks.push({ type: 'text', text: part.text });
+            }
+            else if (part?.functionCall) {
+                const call = part.functionCall;
+                const thoughtSignature = part?.thoughtSignature ?? call?.thoughtSignature;
+                blocks.push({
+                    type: 'tool_use',
+                    id: `toolcall-${Date.now()}-${blocks.length}`,
+                    name: call.name ?? 'tool',
+                    input: call.args ?? {},
+                    ...(thoughtSignature ? { meta: { thought_signature: thoughtSignature } } : {}),
+                });
+            }
+        }
+        return blocks;
+    }
+    parseGeminiChunk(event) {
+        const textChunks = [];
+        const functionCalls = [];
+        const candidates = Array.isArray(event?.candidates) ? event.candidates : [];
+        for (const candidate of candidates) {
+            const parts = candidate?.content?.parts ?? [];
+            for (const part of parts) {
+                if (typeof part?.text === 'string') {
+                    textChunks.push(part.text);
+                }
+                else if (part?.functionCall) {
+                    const thoughtSignature = part?.thoughtSignature ?? part?.functionCall?.thoughtSignature;
+                    functionCalls.push({
+                        name: part.functionCall.name ?? 'tool',
+                        args: part.functionCall.args ?? {},
+                        ...(thoughtSignature ? { thoughtSignature } : {}),
+                    });
+                }
+            }
+        }
+        const usageMetadata = event?.usageMetadata;
+        const usage = usageMetadata
+            ? {
+                input: usageMetadata.promptTokenCount ?? 0,
+                output: usageMetadata.candidatesTokenCount ?? 0,
+            }
+            : undefined;
+        return { textChunks, functionCalls, usage };
+    }
+}
+exports.GeminiProvider = GeminiProvider;

package/dist/infra/providers/index.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Provider Adapters Module
+ *
+ * KODE Agent SDK uses Anthropic-style messages as the internal canonical format.
+ * Each provider is an adapter that converts to/from this internal format.
+ *
+ * Message Flow:
+ * ```
+ * Internal Message[] (Anthropic-style)
+ *   -> Provider.formatMessages() -> External API format
+ *   -> API call
+ *   -> Response -> normalizeContent() -> Internal ContentBlock[]
+ * ```
+ *
+ * Supported Providers:
+ * - AnthropicProvider: Claude models with thinking blocks, files API
+ * - OpenAIProvider: GPT models via Chat Completions or Responses API
+ * - GeminiProvider: Gemini models with thinking support
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeAnthropicDelta = exports.normalizeAnthropicContentBlock = exports.normalizeAnthropicContent = exports.mergeAnthropicBetaHeader = exports.hasAnthropicFileBlocks = exports.sanitizeGeminiSchema = exports.buildGeminiFilePart = exports.buildGeminiImagePart = exports.extractReasoningDetails = exports.splitThinkText = exports.normalizeThinkBlocks = exports.joinReasoningBlocks = exports.concatTextWithReasoning = exports.AUDIO_UNSUPPORTED_TEXT = exports.IMAGE_UNSUPPORTED_TEXT = exports.FILE_UNSUPPORTED_TEXT = exports.safeJsonStringify = exports.formatToolResult = exports.joinTextBlocks = exports.markTransportIfDegraded = exports.getMessageBlocks = exports.normalizeGeminiBaseUrl = exports.normalizeAnthropicBaseUrl = exports.normalizeOpenAIBaseUrl = exports.normalizeBaseUrl = exports.withProxy = exports.getProxyDispatcher = exports.resolveProxyUrl = exports.GeminiProvider = exports.OpenAIProvider = exports.AnthropicProvider = void 0;
+// Provider implementations
+var anthropic_1 = require("./anthropic");
+Object.defineProperty(exports, "AnthropicProvider", { enumerable: true, get: function () { return anthropic_1.AnthropicProvider; } });
+var openai_1 = require("./openai");
+Object.defineProperty(exports, "OpenAIProvider", { enumerable: true, get: function () { return openai_1.OpenAIProvider; } });
+var gemini_1 = require("./gemini");
+Object.defineProperty(exports, "GeminiProvider", { enumerable: true, get: function () { return gemini_1.GeminiProvider; } });
+// Utilities (for custom provider implementations)
+var utils_1 = require("./utils");
+// Proxy
+Object.defineProperty(exports, "resolveProxyUrl", { enumerable: true, get: function () { return utils_1.resolveProxyUrl; } });
+Object.defineProperty(exports, "getProxyDispatcher", { enumerable: true, get: function () { return utils_1.getProxyDispatcher; } });
+Object.defineProperty(exports, "withProxy", { enumerable: true, get: function () { return utils_1.withProxy; } });
+// URL normalization
+Object.defineProperty(exports, "normalizeBaseUrl", { enumerable: true, get: function () { return utils_1.normalizeBaseUrl; } });
+Object.defineProperty(exports, "normalizeOpenAIBaseUrl", { enumerable: true, get: function () { return utils_1.normalizeOpenAIBaseUrl; } });
+Object.defineProperty(exports, "normalizeAnthropicBaseUrl", { enumerable: true, get: function () { return utils_1.normalizeAnthropicBaseUrl; } });
+Object.defineProperty(exports, "normalizeGeminiBaseUrl", { enumerable: true, get: function () { return utils_1.normalizeGeminiBaseUrl; } });
+// Content blocks
+Object.defineProperty(exports, "getMessageBlocks", { enumerable: true, get: function () { return utils_1.getMessageBlocks; } });
+Object.defineProperty(exports, "markTransportIfDegraded", { enumerable: true, get: function () { return utils_1.markTransportIfDegraded; } });
+// Text formatting
+Object.defineProperty(exports, "joinTextBlocks", { enumerable: true, get: function () { return utils_1.joinTextBlocks; } });
+Object.defineProperty(exports, "formatToolResult", { enumerable: true, get: function () { return utils_1.formatToolResult; } });
+Object.defineProperty(exports, "safeJsonStringify", { enumerable: true, get: function () { return utils_1.safeJsonStringify; } });
+// Unsupported content messages
+Object.defineProperty(exports, "FILE_UNSUPPORTED_TEXT", { enumerable: true, get: function () { return utils_1.FILE_UNSUPPORTED_TEXT; } });
+Object.defineProperty(exports, "IMAGE_UNSUPPORTED_TEXT", { enumerable: true, get: function () { return utils_1.IMAGE_UNSUPPORTED_TEXT; } });
+Object.defineProperty(exports, "AUDIO_UNSUPPORTED_TEXT", { enumerable: true, get: function () { return utils_1.AUDIO_UNSUPPORTED_TEXT; } });
+// Reasoning/thinking
+Object.defineProperty(exports, "concatTextWithReasoning", { enumerable: true, get: function () { return utils_1.concatTextWithReasoning; } });
+Object.defineProperty(exports, "joinReasoningBlocks", { enumerable: true, get: function () { return utils_1.joinReasoningBlocks; } });
+Object.defineProperty(exports, "normalizeThinkBlocks", { enumerable: true, get: function () { return utils_1.normalizeThinkBlocks; } });
+Object.defineProperty(exports, "splitThinkText", { enumerable: true, get: function () { return utils_1.splitThinkText; } });
+Object.defineProperty(exports, "extractReasoningDetails", { enumerable: true, get: function () { return utils_1.extractReasoningDetails; } });
+// Gemini helpers
+Object.defineProperty(exports, "buildGeminiImagePart", { enumerable: true, get: function () { return utils_1.buildGeminiImagePart; } });
+Object.defineProperty(exports, "buildGeminiFilePart", { enumerable: true, get: function () { return utils_1.buildGeminiFilePart; } });
+Object.defineProperty(exports, "sanitizeGeminiSchema", { enumerable: true, get: function () { return utils_1.sanitizeGeminiSchema; } });
+// Anthropic helpers
+Object.defineProperty(exports, "hasAnthropicFileBlocks", { enumerable: true, get: function () { return utils_1.hasAnthropicFileBlocks; } });
+Object.defineProperty(exports, "mergeAnthropicBetaHeader", { enumerable: true, get: function () { return utils_1.mergeAnthropicBetaHeader; } });
+Object.defineProperty(exports, "normalizeAnthropicContent", { enumerable: true, get: function () { return utils_1.normalizeAnthropicContent; } });
+Object.defineProperty(exports, "normalizeAnthropicContentBlock", { enumerable: true, get: function () { return utils_1.normalizeAnthropicContentBlock; } });
+Object.defineProperty(exports, "normalizeAnthropicDelta", { enumerable: true, get: function () { return utils_1.normalizeAnthropicDelta; } });
+// Core module (errors, usage, retry, logging, fork)
+__exportStar(require("./core"), exports);