@anyr/ai-sdk-provider 0.1.4 → 0.1.7

package/dist/index.js

@@ -1,12 +1,35 @@
 'use strict';
 
+var provider = require('@ai-sdk/provider');
 var providerUtils = require('@ai-sdk/provider-utils');
 var zod = require('zod');
-var provider = require('@ai-sdk/provider');
 var sdk = require('@anyr/sdk');
 
-// src/anyrouter-chat-language-model.ts
-function convertToAnyRouterChatMessages(prompt) {
+// src/app-attribution.ts
+var APP_SOURCE = "anyr-ai-sdk-provider";
+var APP_TITLE = "AnyRouter AI SDK Provider";
+var APP_VERSION = "0.1.7";
+var PROVIDER_ATTRIBUTION = {
+  source: APP_SOURCE,
+  title: APP_TITLE,
+  version: APP_VERSION
+};
+function buildAppAttributionHeaders(app) {
+  if (!app) return {};
+  const headers = {};
+  const put = (name, value) => {
+    const trimmed = value?.trim();
+    if (trimmed) headers[name] = trimmed;
+  };
+  put("X-AnyRouter-Source", app.source);
+  put("X-AnyRouter-Title", app.title);
+  put("X-AnyRouter-Version", app.version);
+  put("HTTP-Referer", app.url);
+  const categories = app.categories?.map((c) => c.trim()).filter(Boolean);
+  if (categories?.length) headers["X-AnyRouter-Categories"] = categories.join(",");
+  return headers;
+}
+function convertToAnyRouterChatMessages(prompt, fileCache) {
   const messages = [];
   for (const message of prompt) {
     switch (message.role) {
@@ -14,7 +37,7 @@ function convertToAnyRouterChatMessages(prompt) {
         messages.push({ role: "system", content: message.content });
         break;
       case "user":
-        messages.push(convertUserMessage(message));
+        messages.push(convertUserMessage(message, fileCache));
         break;
       case "assistant":
         messages.push(convertAssistantMessage(message));
@@ -34,7 +57,7 @@ function convertToAnyRouterChatMessages(prompt) {
   }
   return messages;
 }
-function convertUserMessage(message) {
+function convertUserMessage(message, fileCache) {
   if (message.content.length === 1 && message.content[0].type === "text") {
     return { role: "user", content: message.content[0].text };
   }
@@ -45,7 +68,7 @@ function convertUserMessage(message) {
     } else if (part.type === "file") {
       const filePart = part;
       const mediaType = filePart.mediaType;
-      const url = toDataUrlOrString(filePart.data, mediaType);
+      const url = fileDataToString(filePart, mediaType, fileCache);
       if (mediaType.startsWith("image/")) {
         parts.push({ type: "image_url", image_url: { url } });
       } else {
@@ -125,13 +148,28 @@ function toolResultOutputToString(output) {
       return JSON.stringify(output);
   }
 }
-function toDataUrlOrString(data, mediaType) {
-  if (data instanceof URL) return data.toString();
-  if (typeof data === "string") {
-    if (data.startsWith("http") || data.startsWith("data:")) return data;
-    return `data:${mediaType};base64,${data}`;
+function fileDataToString(filePart, mediaType, fileCache) {
+  const d = filePart.data;
+  switch (d.type) {
+    case "data": {
+      if (typeof d.data === "string") {
+        if (d.data.startsWith("data:")) return d.data;
+        return `data:${mediaType};base64,${d.data}`;
+      }
+      return `data:${mediaType};base64,${uint8ArrayToBase64(d.data)}`;
+    }
+    case "url":
+      return d.url.toString();
+    case "text":
+      return `data:${mediaType};base64,${btoa(d.text)}`;
+    case "reference": {
+      const entry = fileCache?.lookup(d.reference);
+      if (entry) return entry.url;
+      throw new provider.UnsupportedFunctionalityError({
+        functionality: "Unresolved provider file reference \u2014 call provider.files().uploadFile() first to register the file in the session cache"
+      });
+    }
   }
-  return `data:${mediaType};base64,${uint8ArrayToBase64(data)}`;
 }
 function uint8ArrayToBase64(bytes) {
   let binary = "";
@@ -148,7 +186,11 @@ var anyRouterProviderOptionsSchema = zod.z.object({
   /** Session ID forwarded as `session_id` in the request body. */
   sessionId: zod.z.string().optional(),
   /** Extra body fields merged in last (highest precedence). */
-  extraBody: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+  extraBody: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  /** Cache this response for N seconds, forwarded as the `cf-aig-cache-ttl` header. */
+  cacheTtl: zod.z.number().optional(),
+  /** Skip response caching for this call, forwarded as `cf-aig-skip-cache: true`. */
+  skipCache: zod.z.boolean().optional()
 });
 var anyRouterErrorSchema = zod.z.object({
   error: zod.z.object({
@@ -182,7 +224,7 @@ var toolCallDeltaSchema = zod.z.object({
 var messageSchema = zod.z.object({
   content: zod.z.string().nullish(),
   reasoning_content: zod.z.string().nullish(),
-  tool_calls: zod.z.array(toolCallSchema).optional()
+  tool_calls: zod.z.array(toolCallSchema).nullish()
 });
 var choiceSchema = zod.z.object({
   message: messageSchema.optional(),
@@ -192,12 +234,12 @@ var generateResponseSchema = zod.z.object({
   id: zod.z.string().optional(),
   model: zod.z.string().optional(),
   choices: zod.z.array(choiceSchema).optional(),
-  usage: completionUsageSchema.optional()
+  usage: completionUsageSchema.nullish()
 });
 var deltaSchema = zod.z.object({
   content: zod.z.string().nullish(),
   reasoning_content: zod.z.string().nullish(),
-  tool_calls: zod.z.array(toolCallDeltaSchema).optional()
+  tool_calls: zod.z.array(toolCallDeltaSchema).nullish()
 });
 var streamChoiceSchema = zod.z.object({
   delta: deltaSchema.optional(),
@@ -207,7 +249,10 @@ var streamChunkSchema = zod.z.object({
   id: zod.z.string().optional(),
   model: zod.z.string().optional(),
   choices: zod.z.array(streamChoiceSchema).optional(),
-  usage: completionUsageSchema.optional()
+  usage: completionUsageSchema.nullish(),
+  // A mid-stream failure arrives as a `data: {"error":{...}}` frame on a 200
+  // response, in the same envelope the gateway uses for non-2xx bodies.
+  error: anyRouterErrorSchema.shape.error
 });
 function mapFinishReason(raw) {
   switch (raw) {
@@ -221,6 +266,8 @@ function mapFinishReason(raw) {
       return { unified: "tool-calls", raw };
     case "content_filter":
       return { unified: "content-filter", raw };
+    case "error":
+      return { unified: "error", raw };
     default:
       return { unified: "other", raw: raw ?? void 0 };
   }
@@ -240,6 +287,11 @@ function buildUsage(raw) {
     }
   };
 }
+function mapReasoningEffort(reasoning) {
+  if (!reasoning || reasoning === "provider-default") return void 0;
+  if (reasoning === "xhigh") return "high";
+  return reasoning;
+}
 function emitResponseMetadata(chunk, state, fallbackModelId, controller) {
   if (state.metadataEmitted || !(chunk.id || chunk.model)) return;
   state.metadataEmitted = true;
@@ -292,7 +344,31 @@ function emitToolCallDeltas(toolCalls, acc, controller) {
     }
   }
 }
-function emitFinish(choice, chunk, state, acc, controller) {
+function emitDelta(delta, state, acc, controller) {
+  if (typeof delta.reasoning_content === "string" && delta.reasoning_content.length > 0) {
+    emitReasoningDelta(delta.reasoning_content, state, controller);
+  }
+  if (typeof delta.content === "string" && delta.content.length > 0) {
+    emitTextDelta(delta.content, state, controller);
+  }
+  if (delta.tool_calls) {
+    emitToolCallDeltas(delta.tool_calls, acc, controller);
+  }
+}
+function errorFramePart(chunk, request) {
+  return {
+    type: "error",
+    error: new provider.APICallError({
+      message: chunk.error?.message ?? "AnyRouter API error",
+      url: request.url,
+      requestBodyValues: request.body,
+      responseHeaders: request.responseHeaders,
+      responseBody: JSON.stringify(chunk),
+      data: chunk
+    })
+  };
+}
+function emitFinish(choice, usage, state, acc, controller) {
   closeReasoning(state, controller);
   if (state.activeTextId !== null) {
     controller.enqueue({ type: "text-end", id: state.activeTextId });
@@ -311,8 +387,8 @@ function emitFinish(choice, chunk, state, acc, controller) {
   }
   controller.enqueue({
     type: "finish",
-    usage: buildUsage(chunk.usage),
-    finishReason: mapFinishReason(choice.finish_reason)
+    usage: buildUsage(usage),
+    finishReason: mapFinishReason(choice?.finish_reason)
   });
 }
 function mapToolChoice(toolChoice) {
@@ -360,14 +436,15 @@ function buildTools(tools) {
   }));
   return fns.length > 0 ? fns : void 0;
 }
-function buildRequestBody(modelId, options, settings, stream, perCallOptions) {
-  const messages = convertToAnyRouterChatMessages(options.prompt);
+function buildRequestBody(modelId, options, settings, stream, perCallOptions, fileCache) {
+  const messages = convertToAnyRouterChatMessages(options.prompt, fileCache);
   const responseFormat = buildResponseFormat(options.responseFormat);
   const tools = buildTools(options.tools);
   const toolChoice = mapToolChoice(options.toolChoice);
   const provider = perCallOptions.provider ?? settings.provider;
   const sessionId = perCallOptions.sessionId ?? settings.sessionId;
   const extraBody = { ...settings.extraBody, ...perCallOptions.extraBody };
+  const reasoningEffort = mapReasoningEffort(options.reasoning);
   const body = {
     model: modelId,
     messages,
@@ -385,6 +462,7 @@ function buildRequestBody(modelId, options, settings, stream, perCallOptions) {
     tool_choice: toolChoice,
     provider: provider ?? void 0,
     session_id: sessionId ?? void 0,
+    reasoning_effort: reasoningEffort,
     ...extraBody
   };
   for (const key of Object.keys(body)) {
@@ -392,8 +470,16 @@ function buildRequestBody(modelId, options, settings, stream, perCallOptions) {
   }
   return body;
 }
+function buildCacheHeaders(settings, perCallOptions) {
+  const cacheTtl = perCallOptions.cacheTtl ?? settings.cacheTtl;
+  const skipCache = perCallOptions.skipCache ?? settings.skipCache;
+  const headers = {};
+  if (cacheTtl !== void 0) headers["cf-aig-cache-ttl"] = String(cacheTtl);
+  if (skipCache === true) headers["cf-aig-skip-cache"] = "true";
+  return headers;
+}
 var AnyRouterChatLanguageModel = class {
-  specificationVersion = "v3";
+  specificationVersion = "v4";
   provider;
   modelId;
   supportedUrls = {};
@@ -403,7 +489,6 @@ var AnyRouterChatLanguageModel = class {
     this.provider = config.provider;
     this.config = config;
   }
-  // ─── doGenerate ─────────────────────────────────────────────────────────
   async doGenerate(options) {
     const perCallOptions = await providerUtils.parseProviderOptions({
       provider: "anyrouter",
@@ -415,11 +500,16 @@ var AnyRouterChatLanguageModel = class {
       options,
       this.config.settings,
       false,
-      perCallOptions
+      perCallOptions,
+      this.config.fileCache
     );
     const { value: response, responseHeaders } = await providerUtils.postJsonToApi({
       url: `${this.config.baseURL}/chat/completions`,
-      headers: providerUtils.combineHeaders(this.config.headers(), options.headers),
+      headers: providerUtils.combineHeaders(
+        this.config.headers(),
+        buildCacheHeaders(this.config.settings, perCallOptions),
+        options.headers
+      ),
       body,
       failedResponseHandler: providerUtils.createJsonErrorResponseHandler({
         errorSchema: anyRouterErrorSchema,
@@ -464,17 +554,28 @@ var AnyRouterChatLanguageModel = class {
       }
     };
   }
-  // ─── doStream ───────────────────────────────────────────────────────────
   async doStream(options) {
     const perCallOptions = await providerUtils.parseProviderOptions({
       provider: "anyrouter",
       providerOptions: options.providerOptions,
       schema: anyRouterProviderOptionsSchema
     }) ?? {};
-    const body = buildRequestBody(this.modelId, options, this.config.settings, true, perCallOptions);
+    const body = buildRequestBody(
+      this.modelId,
+      options,
+      this.config.settings,
+      true,
+      perCallOptions,
+      this.config.fileCache
+    );
+    const url = `${this.config.baseURL}/chat/completions`;
     const { value: stream, responseHeaders } = await providerUtils.postJsonToApi({
-      url: `${this.config.baseURL}/chat/completions`,
-      headers: providerUtils.combineHeaders(this.config.headers(), options.headers),
+      url,
+      headers: providerUtils.combineHeaders(
+        this.config.headers(),
+        buildCacheHeaders(this.config.settings, perCallOptions),
+        options.headers
+      ),
       body,
       failedResponseHandler: providerUtils.createJsonErrorResponseHandler({
         errorSchema: anyRouterErrorSchema,
@@ -492,6 +593,8 @@ var AnyRouterChatLanguageModel = class {
       metadataEmitted: false
     };
     const selfModelId = this.modelId;
+    let streamUsage;
+    let finishChoice;
     const transformStream = new TransformStream({
       start(controller) {
         controller.enqueue({ type: "stream-start", warnings: [] });
@@ -502,29 +605,21 @@ var AnyRouterChatLanguageModel = class {
           return;
         }
         const chunk = chunkResult.value;
+        if (chunk.error) {
+          controller.enqueue(errorFramePart(chunk, { url, body, responseHeaders }));
+          finishChoice = { finish_reason: "error" };
+          return;
+        }
         const choice = chunk.choices?.[0];
+        if (chunk.usage) streamUsage = chunk.usage;
         emitResponseMetadata(chunk, state, selfModelId, controller);
-        const delta = choice?.delta;
-        if (delta) {
-          if (typeof delta.reasoning_content === "string" && delta.reasoning_content.length > 0) {
-            emitReasoningDelta(delta.reasoning_content, state, controller);
-          }
-          if (typeof delta.content === "string" && delta.content.length > 0) {
-            emitTextDelta(delta.content, state, controller);
-          }
-          if (delta.tool_calls) {
-            emitToolCallDeltas(delta.tool_calls, toolCallAccumulator, controller);
-          }
-        }
+        if (choice?.delta) emitDelta(choice.delta, state, toolCallAccumulator, controller);
         if (choice?.finish_reason) {
-          emitFinish(choice, chunk, state, toolCallAccumulator, controller);
+          finishChoice = choice;
         }
       },
       flush(controller) {
-        closeReasoning(state, controller);
-        if (state.activeTextId !== null) {
-          controller.enqueue({ type: "text-end", id: state.activeTextId });
-        }
+        emitFinish(finishChoice, streamUsage, state, toolCallAccumulator, controller);
       }
     });
     return {
@@ -552,7 +647,7 @@ var embeddingResponseSchema = zod.z.object({
   }).optional()
 });
 var AnyRouterEmbeddingModel = class {
-  specificationVersion = "v3";
+  specificationVersion = "v4";
   provider;
   modelId;
   /** No hard per-call limit imposed by the provider layer. */
@@ -590,100 +685,109 @@ var AnyRouterEmbeddingModel = class {
     };
   }
 };
-var anyRouterErrorSchema3 = zod.z.object({
-  error: zod.z.object({
-    code: zod.z.string().optional(),
-    message: zod.z.string().optional()
-  }).optional()
-});
-var imageGenerationResponseSchema = zod.z.object({
-  created: zod.z.number().optional(),
-  data: zod.z.array(
-    zod.z.object({
-      url: zod.z.string().optional(),
-      b64_json: zod.z.string().optional(),
-      revised_prompt: zod.z.string().optional()
-    })
-  )
-});
-var AnyRouterImageModel = class {
-  specificationVersion = "v3";
-  provider;
-  modelId;
+
+// src/file-reference-cache.ts
+var PROVIDER_KEY = "anyrouter";
+var FileReferenceCache = class {
+  store = /* @__PURE__ */ new Map();
   /**
-   * Most image generation APIs support only 1 image per call via the
-   * standard `/images/generations` endpoint.
+   * Look up a cached entry via a `SharedV4ProviderReference`.
+   * Returns `undefined` when the reference was not created by this cache.
    */
-  maxImagesPerCall = 1;
-  config;
-  constructor(modelId, config) {
-    this.modelId = modelId;
-    this.provider = config.provider;
-    this.config = config;
+  lookup(reference) {
+    const hash = reference[PROVIDER_KEY];
+    return hash ? this.store.get(hash) : void 0;
   }
-  async doGenerate(options) {
-    if (options.mask) {
-      throw new provider.UnsupportedFunctionalityError({
-        functionality: "mask (inpainting) for AnyRouter image generation"
-      });
-    }
-    const warnings = [];
-    if (options.n > 1) {
-      warnings.push({
-        type: "unsupported",
-        feature: `n=${options.n} (AnyRouter image endpoint supports n=1 per call)`
-      });
-    }
-    const body = {
-      model: this.modelId,
-      prompt: options.prompt ?? "",
-      n: Math.min(options.n, 1),
-      ...options.size ? { size: options.size } : {},
-      ...options.seed !== void 0 ? { seed: options.seed } : {},
-      response_format: "b64_json"
-    };
-    const { value: response, responseHeaders } = await providerUtils.postJsonToApi({
-      url: `${this.config.baseURL}/images/generations`,
-      headers: providerUtils.combineHeaders(this.config.headers(), options.headers),
-      body,
-      failedResponseHandler: providerUtils.createJsonErrorResponseHandler({
-        errorSchema: anyRouterErrorSchema3,
-        errorToMessage: (data) => data.error?.message ?? "AnyRouter images API error",
-        isRetryable: (res) => res.status >= 500
-      }),
-      successfulResponseHandler: providerUtils.createJsonResponseHandler(imageGenerationResponseSchema),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch
-    });
-    const images = [];
-    for (const item of response.data) {
-      if (item.b64_json) {
-        images.push(item.b64_json);
-      } else if (item.url) {
-        images.push(item.url);
-      }
+  /** Add an entry and return the corresponding provider reference. */
+  set(hash, entry) {
+    this.store.set(hash, entry);
+    return { [PROVIDER_KEY]: hash };
+  }
+  /** Returns true when the content hash is already cached. */
+  has(hash) {
+    return this.store.has(hash);
+  }
+  /**
+   * Build a `SharedV4ProviderReference` for the given hash without writing
+   * to the cache.  Use this to construct the return value of `uploadFile`
+   * after confirming the hash is already stored.
+   */
+  referenceFor(hash) {
+    return { [PROVIDER_KEY]: hash };
+  }
+};
+async function hashFileData(data) {
+  let bytes;
+  if (data.type === "text") {
+    bytes = new TextEncoder().encode(data.text);
+  } else if (typeof data.data === "string") {
+    bytes = new TextEncoder().encode(data.data);
+  } else {
+    bytes = data.data;
+  }
+  const hashBuffer = await crypto.subtle.digest("SHA-256", Uint8Array.from(bytes));
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function fileDataVariantToUrl(data, mediaType) {
+  if (data.type === "text") {
+    return `data:${mediaType};base64,${btoa(data.text)}`;
+  }
+  if (typeof data.data === "string") {
+    if (data.data.startsWith("data:")) return data.data;
+    return `data:${mediaType};base64,${data.data}`;
+  }
+  let binary = "";
+  for (let i = 0; i < data.data.length; i++) {
+    binary += String.fromCharCode(data.data[i]);
+  }
+  return `data:${mediaType};base64,${btoa(binary)}`;
+}
+
+// src/anyrouter-files.ts
+var AnyRouterFiles = class {
+  specificationVersion = "v4";
+  provider;
+  cache;
+  constructor(provider, cache) {
+    this.provider = provider;
+    this.cache = cache;
+  }
+  /**
+   * Register a file in the in-session cache and return a provider reference.
+   *
+   * Calling this multiple times with the same file content is idempotent —
+   * the hash check prevents redundant re-encoding.
+   */
+  async uploadFile(options) {
+    const hash = await hashFileData(options.data);
+    if (!this.cache.has(hash)) {
+      const url = fileDataVariantToUrl(options.data, options.mediaType);
+      this.cache.set(hash, { url, mediaType: options.mediaType });
     }
     return {
-      images,
-      warnings,
-      response: {
-        timestamp: /* @__PURE__ */ new Date(),
-        modelId: this.modelId,
-        headers: responseHeaders
-      }
+      providerReference: this.cache.referenceFor(hash),
+      mediaType: options.mediaType,
+      filename: options.filename,
+      warnings: []
     };
   }
 };
 var PROVIDER_ID = "anyrouter";
 function createAnyRouter(options = {}) {
   const baseURL = providerUtils.withoutTrailingSlash(options.baseURL ?? sdk.DEFAULT_BASE_URL) ?? sdk.DEFAULT_BASE_URL;
+  const sharedFileCache = new FileReferenceCache();
   function getHeaders() {
+    const attribution = options.app ? buildAppAttributionHeaders(options.app) : {};
+    if (options.keyless) {
+      return providerUtils.combineHeaders(attribution, options.headers);
+    }
     const apiKey = providerUtils.loadApiKey({
       apiKey: options.apiKey,
       environmentVariableName: "ANYROUTER_API_KEY",
       description: "AnyRouter"
     });
-    return providerUtils.combineHeaders({ Authorization: `Bearer ${apiKey}` }, options.headers);
+    return providerUtils.combineHeaders({ Authorization: `Bearer ${apiKey}`, ...attribution }, options.headers);
   }
   function chatModel(modelId) {
     return new AnyRouterChatLanguageModel(modelId, {
@@ -691,7 +795,8 @@ function createAnyRouter(options = {}) {
       baseURL,
       headers: getHeaders,
       fetch: options.fetch,
-      settings: options
+      settings: options,
+      fileCache: sharedFileCache
     });
   }
   function embeddingModel(modelId) {
@@ -702,37 +807,30 @@ function createAnyRouter(options = {}) {
       fetch: options.fetch
     });
   }
-  function imageModel(modelId) {
-    return new AnyRouterImageModel(modelId, {
-      provider: PROVIDER_ID,
-      baseURL,
-      headers: getHeaders,
-      fetch: options.fetch
-    });
-  }
   const provider$1 = (modelId) => chatModel(modelId);
   const providerObj = Object.assign(provider$1, {
-    // ProviderV3 required fields
-    specificationVersion: "v3",
-    // ProviderV3 required methods
+    // ProviderV4 required fields
+    specificationVersion: "v4",
+    // ProviderV4 required methods
     languageModel(modelId) {
       return chatModel(modelId);
     },
     embeddingModel(modelId) {
       return embeddingModel(modelId);
     },
-    imageModel(modelId) {
-      return imageModel(modelId);
-    },
-    // ProviderV3 optional methods (deprecated textEmbeddingModel alias)
-    textEmbeddingModel(modelId) {
-      return embeddingModel(modelId);
-    },
     // AnyRouter convenience alias
     chat(modelId) {
       return chatModel(modelId);
     },
-    // Unsupported model types — throw NoSuchModelError per ProviderV3 contract
+    // ProviderV4 file-management interface
+    files() {
+      return new AnyRouterFiles(PROVIDER_ID, sharedFileCache);
+    },
+    // Unsupported optional model types — throw NoSuchModelError per ProviderV4 contract.
+    // Image/video generation is not an AnyRouter product (text + embeddings only).
+    imageModel(modelId) {
+      throw new provider.NoSuchModelError({ modelId, modelType: "imageModel" });
+    },
     transcriptionModel(modelId) {
       throw new provider.NoSuchModelError({ modelId, modelType: "transcriptionModel" });
     },
@@ -758,6 +856,9 @@ var anyrouter = createAnyRouter();
 
 exports.AnyRouterChatLanguageModel = AnyRouterChatLanguageModel;
 exports.AnyRouterEmbeddingModel = AnyRouterEmbeddingModel;
-exports.AnyRouterImageModel = AnyRouterImageModel;
+exports.AnyRouterFiles = AnyRouterFiles;
+exports.FileReferenceCache = FileReferenceCache;
+exports.PROVIDER_ATTRIBUTION = PROVIDER_ATTRIBUTION;
 exports.anyrouter = anyrouter;
+exports.buildAppAttributionHeaders = buildAppAttributionHeaders;
 exports.createAnyRouter = createAnyRouter;