@oh-my-pi/pi-coding-agent 14.8.1 → 14.9.1

package/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 ## [Unreleased]
 
+## [14.9.0] - 2026-05-10
+### Breaking Changes
+
+- Moved hashline APIs to the dedicated `@oh-my-pi/pi-coding-agent/hashline` module, moved hash helpers to `@oh-my-pi/pi-coding-agent/hashline/hash`, and removed the legacy `edit/modes/hashline` and `edit/line-hash` source subpaths.
+
+### Removed
+
+- Removed hashline auto-rebase. Anchor mismatches now reject immediately so the model re-reads instead of silently relocating an edit to a hash-collision within ±5 lines, which could otherwise apply the change to the wrong region. Stale-anchor recovery via the cached read snapshot is unaffected.
+
+### Fixed
+
+- Fixed compaction crashing with `auth_unavailable` when the current model's provider has no credentials configured; compaction now falls back to an available model role (or fails fast with a clear error) instead of attempting a doomed provider call ([#986](https://github.com/can1357/oh-my-pi/issues/986)).
+- Fixed top-level static import rewriting in JS evaluation to use parser-based detection so only real import declarations are rewritten and `import` text inside strings, comments, or template literals is preserved
+- Fixed `import ... with` attribute handling in rewritten ESM imports so static imports with module attributes now become dynamic imports with matching `with` options
+- Fixed model resolution silently falling back to a different provider (e.g. Amazon Bedrock) when `modelRoles` specified a fully-qualified `<provider>/<id>` whose exact pair was not in the bundled catalog. Explicit provider prefixes are now honored or surface a clear error ([#980](https://github.com/can1357/oh-my-pi/issues/980)).
+- Fixed session count inflation on Anthropic backend caused by a fresh random `metadata.user_id` being generated on every API request; all requests within one conversation now share a stable `metadata.user_id` derived from the session ID, matching the expected one-session-per-conversation counting
+- Fixed plan mode review resubmits to append each refreshed `local://PLAN.md` preview to the chat history, preserving the full refined plan in terminal scrollback.
+- Fixed compaction requests (manual and auto) not carrying `metadata.user_id`, leaving them unattributed on the backend
+- Fixed direct session-bound LLM calls (`/btw` ephemeral turns via `runEphemeralTurn`, branch summarization, session title generation) bypassing the agent and emitting a fresh random `metadata.user_id` per request on Anthropic OAuth: the session-level `prepareSimpleStreamOptions` helper now stamps the agent's session metadata onto direct calls, and `generateBranchSummary` plus `generateSessionTitle` accept and forward an explicit `metadata` option from the call site
+- Fixed `metadata.user_id` lacking the authenticated `account_uuid` on Anthropic OAuth requests; sessions now install a dynamic resolver via `Agent#setMetadataResolver` that builds `{ session_id, account_uuid? }` per request, looking the live OAuth account UUID up from `AuthStorage` so it stays in sync with token refreshes and login/logout transitions instead of stranding a stale value
+- Fixed multi-file legacy Pi extensions failing to load when sibling `.ts` files import each other via relative paths ([#983](https://github.com/can1357/oh-my-pi/issues/983)).
+- Fixed sub-agent dispatch silently routing to a model whose provider has no working credentials (e.g. an unqualified `modelRoles.task` id like `qwen3.6-plus-free` resolving to a provider the user is not authenticated against). Task dispatch now falls back to the parent session's active model — which by definition has working auth — when the resolved subagent model has none ([#985](https://github.com/can1357/oh-my-pi/issues/985)).
+
+### Added
+
+- Added a debug-panel raw SSE stream viewer so stuck model/tool-call streams can be inspected live from the TUI.
+
+### Fixed
+
+- Fixed legacy Pi plugin extensions failing to load on Windows when their entry path contains a drive letter ([#990](https://github.com/can1357/oh-my-pi/pull/990) by [@jiwangyihao](https://github.com/jiwangyihao)).
+
+### Added
+
+- Added `get_login_providers` RPC command to list registered OAuth providers with their current authentication status (`id`, `name`, `available`, `authenticated`)
+- Added `login` RPC command to trigger OAuth login for a given provider; emits an `open_url` extension UI event (fire-and-forget) carrying the auth URL and optional instructions so headless clients can open the browser, then resolves when the callback-server flow completes
+- Added `open_url` variant to `RpcExtensionUIRequest` for the above
+- Added `getLoginProviders()` and `login(providerId)` methods to `RpcClient`
+
 ## [14.8.0] - 2026-05-09
 ### Added
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "14.8.1",
+	"version": "14.9.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -45,13 +45,14 @@
 	},
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.21.0",
+		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "14.8.1",
-		"@oh-my-pi/pi-agent-core": "14.8.1",
-		"@oh-my-pi/pi-ai": "14.8.1",
-		"@oh-my-pi/pi-natives": "14.8.1",
-		"@oh-my-pi/pi-tui": "14.8.1",
-		"@oh-my-pi/pi-utils": "14.8.1",
+		"@oh-my-pi/omp-stats": "14.9.1",
+		"@oh-my-pi/pi-agent-core": "14.9.1",
+		"@oh-my-pi/pi-ai": "14.9.1",
+		"@oh-my-pi/pi-natives": "14.9.1",
+		"@oh-my-pi/pi-tui": "14.9.1",
+		"@oh-my-pi/pi-utils": "14.9.1",
 		"@puppeteer/browsers": "^2.13.0",
 		"@sinclair/typebox": "^0.34.49",
 		"@types/turndown": "5.0.6",
@@ -227,6 +228,14 @@
 			"types": "./src/edit/modes/*.ts",
 			"import": "./src/edit/modes/*.ts"
 		},
+		"./hashline": {
+			"types": "./src/hashline/index.ts",
+			"import": "./src/hashline/index.ts"
+		},
+		"./hashline/*": {
+			"types": "./src/hashline/*.ts",
+			"import": "./src/hashline/*.ts"
+		},
 		"./exa": {
 			"types": "./src/exa/index.ts",
 			"import": "./src/exa/index.ts"

package/src/config/model-resolver.ts

@@ -16,7 +16,7 @@ import chalk from "chalk";
 import MODEL_PRIO from "../priority.json" with { type: "json" };
 import { parseThinkingLevel, resolveThinkingLevelForModel } from "../thinking";
 import { fuzzyMatch } from "../utils/fuzzy";
-import { MODEL_ROLE_IDS, type ModelRegistry, type ModelRole } from "./model-registry";
+import { isAuthenticated, MODEL_ROLE_IDS, type ModelRegistry, type ModelRole } from "./model-registry";
 import type { Settings } from "./settings";
 
 /** Default model IDs for each known provider */
@@ -326,43 +326,49 @@ function tryMatchModel(
 		return exactCanonicalMatch;
 	}
 
-	// Check for provider/modelId format — fuzzy match within provider
+	// Exact ID match (case-insensitive) — this must happen before provider-scoped
+	// fuzzy matching so raw IDs that contain slashes (for example OpenRouter model
+	// IDs like "openai/gpt-4o:extended") still resolve as IDs instead of being
+	// misread as a provider-qualified selector.
+	const exactMatches = availableModels.filter(m => m.id.toLowerCase() === modelPattern.toLowerCase());
+	if (exactMatches.length > 0) {
+		return pickPreferredModel(exactMatches, context);
+	}
+	// Check for provider/modelId format — fuzzy match within provider only.
 	const slashIndex = modelPattern.indexOf("/");
 	if (slashIndex !== -1) {
 		const provider = modelPattern.substring(0, slashIndex);
 		const modelId = modelPattern.substring(slashIndex + 1);
-
 		const providerModels = availableModels.filter(m => m.provider.toLowerCase() === provider.toLowerCase());
-		if (providerModels.length > 0) {
+		if (providerModels.length === 0) {
+			// The prefix is not a known provider in this candidate set, so treat the
+			// slash as part of the raw model ID and continue with generic matching.
+		} else {
 			const scored = providerModels
 				.map(model => ({ model, match: fuzzyMatch(modelId, model.id) }))
 				.filter(entry => entry.match.matches);
-			if (scored.length > 0) {
-				scored.sort((a, b) => {
-					if (a.match.score !== b.match.score) return a.match.score - b.match.score;
-					const aKey = formatModelString(a.model);
-					const bKey = formatModelString(b.model);
-					const aUsage = context.modelUsageRank.get(aKey) ?? Number.POSITIVE_INFINITY;
-					const bUsage = context.modelUsageRank.get(bKey) ?? Number.POSITIVE_INFINITY;
-					if (aUsage !== bUsage) return aUsage - bUsage;
-
-					const aProviderUsage = context.providerUsageRank.get(a.model.provider) ?? Number.POSITIVE_INFINITY;
-					const bProviderUsage = context.providerUsageRank.get(b.model.provider) ?? Number.POSITIVE_INFINITY;
-					if (aProviderUsage !== bProviderUsage) return aProviderUsage - bProviderUsage;
-
-					const aOrder = context.modelOrder.get(aKey) ?? 0;
-					const bOrder = context.modelOrder.get(bKey) ?? 0;
-					return aOrder - bOrder;
-				});
-				return scored[0]?.model;
+			if (scored.length === 0) {
+				return undefined;
 			}
-		}
-	}
 
-	// Exact ID match (case-insensitive) — with ambiguity across providers handled by preference
-	const exactMatches = availableModels.filter(m => m.id.toLowerCase() === modelPattern.toLowerCase());
-	if (exactMatches.length > 0) {
-		return pickPreferredModel(exactMatches, context);
+			scored.sort((a, b) => {
+				if (a.match.score !== b.match.score) return a.match.score - b.match.score;
+				const aKey = formatModelString(a.model);
+				const bKey = formatModelString(b.model);
+				const aUsage = context.modelUsageRank.get(aKey) ?? Number.POSITIVE_INFINITY;
+				const bUsage = context.modelUsageRank.get(bKey) ?? Number.POSITIVE_INFINITY;
+				if (aUsage !== bUsage) return aUsage - bUsage;
+
+				const aProviderUsage = context.providerUsageRank.get(a.model.provider) ?? Number.POSITIVE_INFINITY;
+				const bProviderUsage = context.providerUsageRank.get(b.model.provider) ?? Number.POSITIVE_INFINITY;
+				if (aProviderUsage !== bProviderUsage) return aProviderUsage - bProviderUsage;
+
+				const aOrder = context.modelOrder.get(aKey) ?? 0;
+				const bOrder = context.modelOrder.get(bKey) ?? 0;
+				return aOrder - bOrder;
+			});
+			return scored[0]?.model;
+		}
 	}
 
 	// No exact match - fall back to partial matching
@@ -688,18 +694,18 @@ export function resolveModelFromSettings(options: {
 }): Model<Api> | undefined {
 	const { settings, availableModels, matchPreferences, roleOrder, modelRegistry } = options;
 	const roles = roleOrder ?? MODEL_ROLE_IDS;
+	let sawConfiguredProviderQualifiedRole = false;
 	for (const role of roles) {
 		const configured = settings.getModelRole(role);
 		if (!configured) continue;
-		const resolved = resolveModelFromString(
-			expandRoleAlias(configured, settings),
-			availableModels,
-			matchPreferences,
-			modelRegistry,
-		);
+		const expanded = expandRoleAlias(configured, settings).trim();
+		if (expanded.includes("/")) {
+			sawConfiguredProviderQualifiedRole = true;
+		}
+		const resolved = resolveModelFromString(expanded, availableModels, matchPreferences, modelRegistry);
 		if (resolved) return resolved;
 	}
-	return availableModels[0];
+	return sawConfiguredProviderQualifiedRole ? undefined : availableModels[0];
 }
 
 /**
@@ -726,6 +732,57 @@ export function resolveModelOverride(
 	return { explicitThinkingLevel: false };
 }
 
+/**
+ * Resolve a list of override patterns to the first matching model, with an
+ * auth-aware fallback to the parent session's active model.
+ *
+ * If the resolved subagent model has no working credentials (provider has no
+ * usable auth), and the parent's active model resolves with working auth,
+ * use the parent's model instead. This prevents subagent dispatch from
+ * silently routing to a provider the user can't actually call (e.g.
+ * `modelRoles.task` pointing at an unqualified id whose only available
+ * provider variant has no configured credentials — see #985).
+ *
+ * If neither the subagent nor the parent has working auth, returns the
+ * primary resolution unchanged so the existing error path still surfaces
+ * a meaningful failure downstream.
+ */
+export async function resolveModelOverrideWithAuthFallback(
+	modelPatterns: string[],
+	parentActiveModelPattern: string | undefined,
+	modelRegistry: ModelLookupRegistry & Pick<ModelRegistry, "getApiKey">,
+	settings?: Settings,
+): Promise<{
+	model?: Model<Api>;
+	thinkingLevel?: ThinkingLevel;
+	explicitThinkingLevel: boolean;
+	authFallbackUsed: boolean;
+}> {
+	const primary = resolveModelOverride(modelPatterns, modelRegistry, settings);
+	if (!primary.model || !parentActiveModelPattern) {
+		return { ...primary, authFallbackUsed: false };
+	}
+
+	const primaryKey = await modelRegistry.getApiKey(primary.model);
+	if (isAuthenticated(primaryKey)) {
+		return { ...primary, authFallbackUsed: false };
+	}
+
+	const fallback = resolveModelOverride([parentActiveModelPattern], modelRegistry, settings);
+	if (!fallback.model) {
+		return { ...primary, authFallbackUsed: false };
+	}
+	if (modelsAreEqual(fallback.model, primary.model)) {
+		return { ...primary, authFallbackUsed: false };
+	}
+	const fallbackKey = await modelRegistry.getApiKey(fallback.model);
+	if (!isAuthenticated(fallbackKey)) {
+		return { ...primary, authFallbackUsed: false };
+	}
+
+	return { ...fallback, authFallbackUsed: true };
+}
+
 /**
  * Resolve a list of role patterns to the first matching model.
  */

package/src/config/prompt-templates.ts

@@ -8,7 +8,7 @@ import {
 	parseFrontmatter,
 	prompt,
 } from "@oh-my-pi/pi-utils";
-import { computeLineHash, HL_BODY_SEP, HL_EDIT_SEP } from "../edit/line-hash";
+import { computeLineHash, HL_BODY_SEP, HL_EDIT_SEP } from "../hashline/hash";
 import { jtdToTypeScript } from "../tools/jtd-to-typescript";
 import { parseCommandArgs, substituteArgs } from "../utils/command-args";
 

package/src/debug/index.ts

@@ -15,6 +15,8 @@ import { formatBytes } from "../tools/render-utils";
 import { openPath } from "../utils/open";
 import { DebugLogViewerComponent } from "./log-viewer";
 import { generateHeapSnapshotData, type ProfilerSession, startCpuProfile } from "./profiler";
+import { RawSseViewerComponent } from "./raw-sse";
+import { resolveRawSseDebugBuffer } from "./raw-sse-buffer";
 import { clearArtifactCache, createDebugLogSource, createReportBundle, getArtifactCacheStats } from "./report-bundle";
 import { collectSystemInfo, formatSystemInfo } from "./system-info";
 
@@ -27,6 +29,7 @@ const DEBUG_MENU_ITEMS: SelectItem[] = [
 	{ value: "memory", label: "Report: memory issue", description: "Heap snapshot + bundle" },
 	{ value: "logs", label: "View: recent logs", description: "Show last 50 log entries" },
 	{ value: "system", label: "View: system info", description: "Show environment details" },
+	{ value: "raw-sse", label: "View: raw SSE stream", description: "Show live provider SSE frames" },
 	{
 		value: "transcript",
 		label: "Export: TUI transcript",
@@ -97,6 +100,9 @@ export class DebugSelectorComponent extends Container {
 			case "logs":
 				await this.#handleViewLogs();
 				break;
+			case "raw-sse":
+				await this.#handleViewRawSse();
+				break;
 			case "system":
 				await this.#handleViewSystemInfo();
 				break;
@@ -315,6 +321,21 @@ export class DebugSelectorComponent extends Container {
 		this.ctx.ui.requestRender();
 	}
 
+	async #handleViewRawSse(): Promise<void> {
+		const viewer = new RawSseViewerComponent({
+			buffer: resolveRawSseDebugBuffer(this.ctx.session),
+			terminalRows: this.ctx.ui.terminal.rows,
+			onExit: () => this.ctx.showDebugSelector(),
+			onStatus: message => this.ctx.showStatus(message, { dim: true }),
+			onUpdate: () => this.ctx.ui.requestRender(),
+		});
+
+		this.ctx.editorContainer.clear();
+		this.ctx.editorContainer.addChild(viewer);
+		this.ctx.ui.setFocus(viewer);
+		this.ctx.ui.requestRender();
+	}
+
 	async #handleViewSystemInfo(): Promise<void> {
 		try {
 			const info = await collectSystemInfo();

package/src/debug/raw-sse-buffer.ts

@@ -0,0 +1,229 @@
+import type { Model, ProviderResponseMetadata, RawSseEvent } from "@oh-my-pi/pi-ai";
+
+const MAX_RAW_SSE_EVENTS = 1_000;
+const MAX_RAW_SSE_CHARS = 512_000;
+const MAX_RAW_SSE_EVENT_CHARS = 64_000;
+
+export type RawSseDebugRecord =
+	| {
+			kind: "response";
+			sequence: number;
+			timestamp: number;
+			provider?: string;
+			model?: string;
+			api?: string;
+			status: number;
+			requestId?: string | null;
+			transport?: string;
+	  }
+	| {
+			kind: "event";
+			sequence: number;
+			timestamp: number;
+			provider?: string;
+			model?: string;
+			api?: string;
+			event: string | null;
+			raw: string[];
+			truncated: boolean;
+			originalChars: number;
+	  };
+
+export interface RawSseDebugSnapshot {
+	records: readonly RawSseDebugRecord[];
+	droppedRecords: number;
+	droppedChars: number;
+	totalEvents: number;
+	lastUpdatedAt?: number;
+}
+
+function modelProvider(model: Model | undefined): string | undefined {
+	return model?.provider;
+}
+
+function modelId(model: Model | undefined): string | undefined {
+	return model?.id;
+}
+
+function modelApi(model: Model | undefined): string | undefined {
+	return model?.api;
+}
+
+function countRecordChars(record: RawSseDebugRecord): number {
+	if (record.kind === "response") return formatRawSseResponseComment(record).length + 1;
+	return record.raw.reduce((sum, line) => sum + line.length + 1, 1);
+}
+
+function trimRawLines(raw: string[]): { raw: string[]; truncated: boolean; originalChars: number } {
+	const originalChars = raw.reduce((sum, line) => sum + line.length + 1, 0);
+	if (originalChars <= MAX_RAW_SSE_EVENT_CHARS) {
+		return { raw: [...raw], truncated: false, originalChars };
+	}
+
+	const trimmed: string[] = [];
+	let remaining = MAX_RAW_SSE_EVENT_CHARS;
+	for (const line of raw) {
+		if (remaining <= 0) break;
+		if (line.length + 1 <= remaining) {
+			trimmed.push(line);
+			remaining -= line.length + 1;
+			continue;
+		}
+		trimmed.push(line.slice(0, Math.max(0, remaining)));
+		remaining = 0;
+	}
+	trimmed.push(`: omp-debug-truncated originalChars=${originalChars}`);
+	return { raw: trimmed, truncated: true, originalChars };
+}
+
+export function formatRawSseIsoTime(timestamp: number): string {
+	return new Date(timestamp).toISOString();
+}
+
+export function formatRawSseResponseComment(record: Extract<RawSseDebugRecord, { kind: "response" }>): string {
+	const fields = [
+		"omp-response",
+		`ts=${formatRawSseIsoTime(record.timestamp)}`,
+		`status=${record.status}`,
+		record.provider ? `provider=${record.provider}` : undefined,
+		record.model ? `model=${record.model}` : undefined,
+		record.api ? `api=${record.api}` : undefined,
+		record.requestId ? `requestId=${record.requestId}` : undefined,
+		record.transport ? `transport=${record.transport}` : undefined,
+	].filter((field): field is string => field !== undefined);
+	return `: ${fields.join(" ")}`;
+}
+
+export function rawSseRecordLines(record: RawSseDebugRecord): string[] {
+	if (record.kind === "response") return [formatRawSseResponseComment(record)];
+	return record.raw;
+}
+
+function rawRecordText(record: RawSseDebugRecord): string {
+	return `${rawSseRecordLines(record).join("\n")}\n`;
+}
+
+function metadataTransport(response: ProviderResponseMetadata): string | undefined {
+	const value = response.metadata?.lastTransport;
+	return typeof value === "string" ? value : undefined;
+}
+
+export class RawSseDebugBuffer {
+	#records: RawSseDebugRecord[] = [];
+	#totalChars = 0;
+	#droppedRecords = 0;
+	#droppedChars = 0;
+	#totalEvents = 0;
+	#lastUpdatedAt: number | undefined;
+	#nextSequence = 1;
+	#listeners = new Set<() => void>();
+
+	subscribe(listener: () => void): () => void {
+		this.#listeners.add(listener);
+		return () => this.#listeners.delete(listener);
+	}
+
+	recordResponse(response: ProviderResponseMetadata, model?: Model): void {
+		this.#append({
+			kind: "response",
+			sequence: this.#nextSequence++,
+			timestamp: Date.now(),
+			provider: modelProvider(model),
+			model: modelId(model),
+			api: modelApi(model),
+			status: response.status,
+			requestId: response.requestId,
+			transport: metadataTransport(response),
+		});
+	}
+
+	recordEvent(event: RawSseEvent, model?: Model): void {
+		const trimmed = trimRawLines(event.raw);
+		this.#totalEvents += 1;
+		this.#append({
+			kind: "event",
+			sequence: this.#nextSequence++,
+			timestamp: Date.now(),
+			provider: modelProvider(model),
+			model: modelId(model),
+			api: modelApi(model),
+			event: event.event,
+			raw: trimmed.raw,
+			truncated: trimmed.truncated,
+			originalChars: trimmed.originalChars,
+		});
+	}
+
+	snapshot(): RawSseDebugSnapshot {
+		return {
+			records: [...this.#records],
+			droppedRecords: this.#droppedRecords,
+			droppedChars: this.#droppedChars,
+			totalEvents: this.#totalEvents,
+			lastUpdatedAt: this.#lastUpdatedAt,
+		};
+	}
+
+	toRawText(): string {
+		return this.#records.map(rawRecordText).join("\n");
+	}
+
+	#append(record: RawSseDebugRecord): void {
+		const chars = countRecordChars(record);
+		this.#records.push(record);
+		this.#totalChars += chars;
+		this.#lastUpdatedAt = record.timestamp;
+		this.#enforceLimits();
+		this.#emit();
+	}
+
+	#enforceLimits(): void {
+		while (this.#records.length > MAX_RAW_SSE_EVENTS || this.#totalChars > MAX_RAW_SSE_CHARS) {
+			const dropped = this.#records.shift();
+			if (!dropped) return;
+			const chars = countRecordChars(dropped);
+			this.#totalChars = Math.max(0, this.#totalChars - chars);
+			this.#droppedRecords += 1;
+			this.#droppedChars += chars;
+		}
+	}
+
+	#emit(): void {
+		for (const listener of this.#listeners) {
+			try {
+				listener();
+			} catch {
+				// Debug viewers must not be able to break stream capture.
+			}
+		}
+	}
+}
+
+const fallbackBuffers = new WeakMap<object, RawSseDebugBuffer>();
+const globalFallbackBuffer = new RawSseDebugBuffer();
+
+export function resolveRawSseDebugBuffer(owner?: object): RawSseDebugBuffer {
+	if (!owner) return globalFallbackBuffer;
+
+	const candidate = (owner as { rawSseDebugBuffer?: unknown }).rawSseDebugBuffer;
+	if (candidate instanceof RawSseDebugBuffer) return candidate;
+
+	const existing = fallbackBuffers.get(owner);
+	if (existing) return existing;
+
+	const buffer = new RawSseDebugBuffer();
+	fallbackBuffers.set(owner, buffer);
+	if (Object.isExtensible(owner)) {
+		try {
+			Object.defineProperty(owner, "rawSseDebugBuffer", {
+				value: buffer,
+				configurable: true,
+				enumerable: false,
+				writable: true,
+			});
+		} catch {
+			// The WeakMap fallback remains usable if the session object rejects extension.
+		}
+	}
+	return buffer;
+}